From 2ef178f1556460db72f9aa3627e31564fb029383 Mon Sep 17 00:00:00 2001 From: yeonjuan Date: Thu, 23 Apr 2020 03:25:10 +0900 Subject: [PATCH] 2020-04-23-03 --- _gitbook_plugin_analytics.js | 4 +- googlee9f11f9e5eb0999e.html | 1 + index.html | 73 +- pages/Advanced Types.html | 831 ++++++++--- pages/Basic Types.html | 242 +++- pages/Classes.html | 265 ++-- pages/Compiler Options in MSBuild.html | 58 +- pages/Compiler Options.html | 58 +- pages/Declaration Merging.html | 185 ++- pages/Decorators.html | 259 ++-- pages/Enums.html | 213 ++- pages/Functions.html | 304 +++-- pages/Generics.html | 227 +++- pages/Integrating with Build Tools.html | 54 +- pages/Interfaces.html | 487 ++++--- pages/Iterators and Generators.html | 123 +- pages/JSX.html | 335 +++-- pages/Mixins.html | 119 +- pages/Module Resolution.html | 353 +++-- pages/Modules.html | 399 ++++-- pages/Namespaces and Modules.html | 122 +- pages/Namespaces.html | 185 ++- pages/Nightly Builds.html | 62 +- pages/Project References.html | 993 ++++++++++++++ pages/Symbols.html | 103 +- pages/Triple-Slash Directives.html | 138 +- pages/Type Checking JavaScript Files.html | 677 ++++++++- pages/Type Compatibility.html | 215 +-- pages/Type Inference.html | 123 +- pages/Utility Types.html | 1087 +++++++++++++++ pages/Variable Declarations.html | 384 ++++-- pages/declaration files/By Example.html | 200 +-- pages/declaration files/Consumption.html | 86 +- pages/declaration files/Deep Dive.html | 264 ++-- pages/declaration files/Do's and Don'ts.html | 189 ++- pages/declaration files/Introduction.html | 113 +- .../declaration files/Library Structures.html | 381 +++--- pages/declaration files/Publishing.html | 129 +- pages/declaration files/Templates.html | 54 +- pages/release notes/TypeScript 3.8.html | 1210 +++++++++++++++++ pages/tsconfig.json.html | 57 +- pages/tutorials/ASP.NET Core.html | 54 +- pages/tutorials/Gulp.html | 54 +- .../tutorials/Migrating from JavaScript.html | 56 +- pages/tutorials/React & Webpack.html | 216 ++- pages/tutorials/TypeScript in 5 minutes.html | 137 +- search_index.json | 2 +- sitemap.xml | 3 + 48 files changed, 9386 insertions(+), 2498 deletions(-) create mode 100644 googlee9f11f9e5eb0999e.html create mode 100644 pages/Project References.html create mode 100644 pages/Utility Types.html create mode 100644 pages/release notes/TypeScript 3.8.html diff --git a/_gitbook_plugin_analytics.js b/_gitbook_plugin_analytics.js index 21f49a1d..26fc99d2 100644 --- a/_gitbook_plugin_analytics.js +++ b/_gitbook_plugin_analytics.js @@ -1,9 +1,9 @@ -if ('UA-163809183-2') { +if ('UA-99001722-6') { (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){ (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o), m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m) })(window,document,'script','https://www.google-analytics.com/analytics.js','ga'); - ga('create', 'UA-163809183-2', 'auto'); + ga('create', 'UA-99001722-6', 'auto'); ga('send', 'pageview'); } diff --git a/googlee9f11f9e5eb0999e.html b/googlee9f11f9e5eb0999e.html new file mode 100644 index 00000000..71433c57 --- /dev/null +++ b/googlee9f11f9e5eb0999e.html @@ -0,0 +1 @@ +google-site-verification: googlee9f11f9e5eb0999e.html \ No newline at end of file diff --git a/index.html b/index.html index ad3a80e7..ed5b6e06 100644 --- a/index.html +++ b/index.html @@ -479,6 +479,19 @@ + + +
  • + + + + + 유틸리티 타입 + + + + +
    • @@ -625,7 +638,20 @@ -
  • +
  • + + + + + 프로젝트 레퍼런스 + + + + + +
    • + +
  • @@ -638,7 +664,7 @@
    • -
  • +
  • @@ -651,7 +677,7 @@
    • -
  • +
  • @@ -666,6 +692,26 @@ + +
  • 릴리즈 노트
    • + + + +
  • + + + + + TypeScript 3.8 + + + + + +
    • + + +
  • @@ -710,18 +756,13 @@

    TypeScript-Handbook 한글 문서

    -

    Build Status

    -

    TypeScript Handbook을 번역하는 저장소입니다.

    -

    번역 품질

    -

    초보 번역가이며 기초적인 Java 지식과 JavaScript 개발을 주로하는 개발자들이 함께 번역했습니다.
    TypeScript 번역을 하며 전문적이거나 의미론적인 지식이 많이 필요했었습니다.
    때문에 오역과 의역이 있을 수 있습니다.
    단어의 선정이나 규칙은 구글 검색량과 IT 전문 사전을 대체로 참고하였으며 모던하게 주로 쓰이는 단어를 우선 순위로 두었습니다.

    -

    번역 범위

    -

    TypeScript Handbook의 모든 페이지를 번역할 예정입니다.

    -

    향후 MS측의 TypeScript 공식 번역이 지원되지 않는다면 TypeScript 홈페이지의 모든 부분과 릴리즈 버전에 대한 번역도 할 의지가 있습니다.

    -

    진행 상황

    -

    이곳을 통해 확인할 수 있습니다.

    -

    기여

    -

    번역가이드 및 규칙을 참고하여 develop 브랜치에 PR 해주시면 됩니다.

    -

    깃헙 사용이 어렵거나 간단한 의견 같은 경우에는 이슈 등록을 해주시면 감사하겠습니다

    +

    Build Status

    +

    TypeScript Handbook을 번역하는 프로젝트입니다.

    +

    진행 상황

    +

    번역 진행 상황은 이곳을 통해 확인할 수 있습니다.

    +

    참여하기

    +

    누구나 참여 가능하며 참여하는 방법은 번역가이드 및 규칙과 CONTRIBUTING.md를 참고해 주세요.

    +

    잘못된 번역, 오타, 번역 요청은 이슈에 등록 해주시면 감사하겠습니다.

    그 밖에도 다양한 의견 및 피드백은 언제나 환영합니다:)

    @@ -762,7 +803,7 @@

    No results matching " var gitbook = gitbook || []; gitbook.push(function() { - gitbook.page.hasChanged({"page":{"title":"소개","level":"1.1","depth":1,"next":{"title":"5분 안에 보는 TypeScript","level":"2.1","depth":1,"path":"pages/tutorials/TypeScript in 5 minutes.md","ref":"pages/tutorials/TypeScript in 5 minutes.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"README.md","mtime":"2019-06-14T05:35:15.551Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":".","book":{"language":""}}); + gitbook.page.hasChanged({"page":{"title":"소개","level":"1.1","depth":1,"next":{"title":"5분 안에 보는 TypeScript","level":"2.1","depth":1,"path":"pages/tutorials/TypeScript in 5 minutes.md","ref":"pages/tutorials/TypeScript in 5 minutes.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"README.md","mtime":"2020-04-22T16:05:13.080Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":".","book":{"language":""}}); }); diff --git a/pages/Advanced Types.html b/pages/Advanced Types.html index cd9e145d..00382d75 100644 --- a/pages/Advanced Types.html +++ b/pages/Advanced Types.html @@ -481,6 +481,19 @@ + + +
  • + + + + + 유틸리티 타입 + + + + +
    • @@ -627,7 +640,20 @@ -
  • +
  • + + + + + 프로젝트 레퍼런스 + + + + + +
    • + +
  • @@ -640,7 +666,7 @@
    • -
  • +
  • @@ -653,7 +679,7 @@
    • -
  • +
  • @@ -668,6 +694,26 @@ + +
  • 릴리즈 노트
    • + + + +
  • + + + + + TypeScript 3.8 + + + + + +
    • + + +
  • @@ -711,46 +757,98 @@

    -

    교차 타입 (Intersection Types)

    -

    교차 타입은 다양한 타입을 하나로 결합합니다.
    따라서 기존 타입을 추가하여 필요한 모든 기능을 갖춘 단일 타입을 얻을 수 있습니다.

    -

    예를 들어 Person & Serializable & Loggable은 Person 과 Serializable 이며 Loggable 입니다.
    즉 이 타입의 객체는 세 가지 타입의 모든 멤버를 갖게됩니다.

    -

    믹스인에 사용되는 교차 타입과 고전적인 객체 지향 형식에 맞지 않는 다른 개념을 볼 수 있습니다.
    (JavaScript에 이러한 것들이 많습니다!)

    -

    여기에 Mixin을 만드는 방법을 보여 주는 간단한 예제가 있습니다 :

    -
    function extend<T, U>(first: T, second: U): T & U {
-    let result = <T & U>{};
-    for (let id in first) {
-        (<any>result)[id] = (<any>first)[id];
+                                
    목차 (Table of contents)
    
+
    교차 타입 (Intersection Types)
    
+
    유니언 타입 (Union Types)
    
+
    타입 가드와 차별 타입 (Type Guards and Differentiating Types)
    
+
+
    널러블 타입 (Nullable types)
    
+
+
    타입 별칭 (Type Aliases)
    
+
+
    문자열 리터럴 타입 (String Literal Types)
    
+
    숫자 리터럴 타입 (Numeric Literal Types)
    
+
    열거형 멤버 타입 (Enum Member Types)
    
+
    판별 유니언
    
+
+
    다형성 this 타입
    
+
    인덱스 타입
    
+
+
    매핑 타입
    
+
+
    조건부 타입
    
+
+
    교차 타입 (Intersection Types)
    
+
    교차 타입은 여러 타입을 하나로 결합합니다.
+기존 타입을 합쳐 필요한 모든 기능을 가진 하나의 타입을 얻을 수 있습니다.
+예를 들어, Person & Serializable & Loggable은 Person 과 Serializable 그리고 Loggable입니다.
+즉, 이 타입의 객체는 세 가지 타입의 모든 멤버를 갖게 됩니다.
    
+
    기존 객체-지향 틀과는 맞지 않는 믹스인이나 다른 컨셉들에서 교차 타입이 사용되는 것을 볼 수 있습니다.
+(JavaScript에는 이런 것들이 많습니다!)
+믹스인 만드는 방법을 간단한 예제를 통해 살펴보겠습니다:
    
+
    function extend<First, Second>(first: First, second: Second): First & Second {
+    const result: Partial<First & Second> = {};
+    for (const prop in first) {
+        if (first.hasOwnProperty(prop)) {
+            (result as First)[prop] = first[prop];
+        }
     }
-    for (let id in second) {
-        if (!result.hasOwnProperty(id)) {
-            (<any>result)[id] = (<any>second)[id];
+    for (const prop in second) {
+        if (second.hasOwnProperty(prop)) {
+            (result as Second)[prop] = second[prop];
         }
     }
-    return result;
+    return result as First & Second;
 }
 
 class Person {
     constructor(public name: string) { }
 }
+
 interface Loggable {
-    log(): void;
+    log(name: string): void;
 }
+
 class ConsoleLogger implements Loggable {
-    log() {
-        // ...
+    log(name) {
+        console.log(`Hello, I'm ${name}.`);
     }
 }
-var jim = extend(new Person("Jim"), new ConsoleLogger());
-var n = jim.name;
-jim.log();
+
+const jim = extend(new Person('Jim'), ConsoleLogger.prototype);
+jim.log(jim.name);
 
    
-
    유니온 타입 (Union Types)
    
-
    유니온 타입은 교차 타입과 밀접한 관련이 있지만 매우 다르게 사용됩니다.
    때로는 매개 변수가 number 또는string이 될 것으로 기대하는 라이브러리를 실행하게 됩니다.
    
-
    예를 들어 다음과 같은 함수을 수행하십시오:
    
+
    유니언 타입 (Union Types)
    
+
    유니언 타입은 교차 타입과 밀접하게 관련되어 있지만, 매우 다르게 사용됩니다.
+가끔, 숫자나 문자열을 매개변수로 기대하는 라이브러리를 사용할 때가 있습니다.
+예를 들어, 다음 함수를 사용할 때입니다:
    
 
    /**
- * string 타입을 가져와서 왼쪽에 "padding"을 추가합니다.
- * 'padding'이 string인 경우에는 'padding'이 왼쪽에 추가됩니다.
- * 'padding'이 number인 경우에는 해당 개수의 공백이 왼쪽에 추가됩니다.
+ * 문자열을 받고 왼쪽에 "padding"을 추가합니다.
+ * 만약 'padding'이 문자열이라면, 'padding'은 왼쪽에 더해질 것입니다.
+ * 만약 'padding'이 숫자라면, 그 숫자만큼의 공백이 왼쪽에 더해질 것입니다.
  */
 function padLeft(value: string, padding: any) {
     if (typeof padding === "number") {
@@ -762,26 +860,32 @@ 
    유니&
     throw new Error(`Expected string or number, got '${padding}'.`);
 }
 
-padLeft("Hello world", 4); // "    Hello world" 반환
+padLeft("Hello world", 4); // "    Hello world"를 반환합니다.
 
    
-
    padLeft의 문제점은 padding 매개 변수가 any로 분류된다는 것입니다.
    즉 number이거나 string이 아닌 인수를 사용하여 호출할 수 있지만 TypeScript는 해당 인수와 함께 사용할 수 있습니다.
    
-
    let indentedString = padLeft("Hello world", true); // 컴파일 타임에는 통과되지만 런타임에는 실패합니다.
+
    padLeft의 문제는 매개변수 padding이 any 타입으로 되어있다는 것입니다.
+즉, 숫자나 문자열 둘 다 아닌 인수로 호출할 수 있다는 것이고, TypeScript는 이를 괜찮다고 받아들일 것입니다.
    
+
    let indentedString = padLeft("Hello world", true); // 컴파일 타임에 통과되고, 런타임에 오류.
 
    
-
    전통적인 객체 지향 코드에서는 타입의 계층을 만들어 두 가지 타입을 추상화 할 수 있습니다.
    이것이 훨씬 더 명백하기는 하지만 또 약간 지나치기도 합니다.
    padLeft의 원래 버전에 대한 좋은 점 중 하나는 원시 값을 전달할 수 있다는 것입니다.
    이는 사용법이 간단하고 간결하다는 것을 의미했습니다.
    이 새로운 접근법은 이미 다른 곳에 있는 함수를 사용하려는 경우에도 도움이 되지 않습니다.
    
-
    any 대신 padding 매개변수에 union type 을 사용할 수 있습니다:
    
+
    전통적인 객체지향 코드에서, 타입의 계층을 생성하여 두 타입을 추상화할 수 있습니다.
+이는 더 명시적일 수는 있지만, 좀 과하다고 할 수도 있습니다.
+전통적인 방법의 padLeft에서 좋은 점은 그냥 원시 값을 전달할 수 있다는 것입니다.
+즉 사용법이 간단하고 간결합니다.
+이 새로운 방법은 다른 곳에서 이미 존재하는 함수를 사용하려 할 때, 도움이 되지 않습니다.
    
+
    any 대신에, 유니언 타입을 매개변수 padding에 사용할 수 있습니다:
    
 
    /**
- * string 타입을 가져와서 왼쪽에 "padding"을 추가합니다.
- * 'padding'이 string인 경우에는 'padding'이 왼쪽에 추가됩니다.
- * 'padding'이 number인 경우에는 해당 개수의 공백이 왼쪽에 추가됩니다.
+ * 문자열을 받고 왼쪽에 "padding"을 추가합니다.
+ * 만약 'padding'이 문자열이라면, 'padding'은 왼쪽에 더해질 것입니다.
+ * 만약 'padding'이 숫자라면, 그 숫자만큼의 공백이 왼쪽에 더해질 것입니다.
  */
 function padLeft(value: string, padding: string | number) {
     // ...
 }
 
-let indentedString = padLeft("Hello world", true); // 컴파일 시 오류
+let indentedString = padLeft("Hello world", true); // 컴파일 중에 오류
 
    
-
    유니온 타입은 여러 타입 중 하나일 수 있는 값을 설명합니다.
    각 타입을 구분하기 위해 수직 막대(|)를 사용하므로 number | string | boolean은 number, string 또는 boolean 될 수 있는 값의 타입입니다.
    
-
    유니온 타입이 있는 값이 있으면 유니온의 모든 타입에 공통적인 멤버에만 접근할 수 있습니다.
    
+
    유니언 타입은 값이 여러 타입 중 하나임을 설명합니다.
+세로 막대 (|)로 각 타입을 구분하여 number | string | boolean은 값의 타입이 number, string 혹은 boolean이 될 수 있음을 나타냅니다.
    
+
    유니언 타입을 값으로 가지고 있으면, 유니언에 있는 모든 타입에 공통인 멤버에만 접근할 수 있습니다.
    
 
    interface Bird {
     fly();
     layEggs();
@@ -797,16 +901,22 @@ 
    유니&
 }
 
 let pet = getSmallPet();
-pet.layEggs(); // 좋아요
+pet.layEggs(); // 성공
 pet.swim();    // 오류
 
    
-
    유니온 타입이 좀 까다로울 수도 있지만 익숙해지는 데는 약간의 직관이 필요할 뿐입니다.
    어떠한 값에 A | B 타입이 있다면 A 와 B 모두 가지고 있는 멤버가 있음을 확실히 알고 있습니다.
    이 예제에서 Bird는 fly라는 멤버를 가지고 있습니다.
    하지만 Bird | Fish의 변수 타입이 fly 메서드로 작용하고 있는지는 알 수 없습니다.
    런타임에 변수가 Fish 인경우 pet.fly() 호출은 실패합니다.
    
-
    타입 가드와 차별된 타입 (Type Guards and Differentiating Types)
    
-
    유니온 타입은 값을 취할 수있는 타입으로 겹칠 수있는 상황을 모델링 할 때 유용합니다.
    Fish를 가지고 있는지에 대해 구체적으로 알아야 할 필요가 있을 때 무슨 일이 일어날까요?
    JavaScript에서 두 가지 가능한 값을 구별하는 일반적인 용어는 멤버의 존재를 확인하는 것입니다.
-언급했듯이 유니온 타입의 모든 구성 요소에 포함될 수 있는 보장된 멤버에만 접근할 수 있습니다.
    
+
    유니언 타입은 여기서 약간 까다로울 수 있으나, 익숙해지는데 약간의 직관만 있으면 됩니다.
+만약 값이 A | B 타입을 가지고 있으면, 확신할 수 있는 것은 A 와 B 둘 다 가지고 있는 멤버가 있다는 것뿐입니다.
+이 예제에서, Bird는 fly를 멤버로 가지고 있습니다.
+Bird | Fish로 타입이 지정된 변수가 fly 메서드를 가지고 있는지 확신할 수 없습니다
+만약 변수가 실제로 런타임에 Fish이면, pet.fly()를 호출하는 것은 오류입니다.
    
+
    타입 가드와 차별 타입 (Type Guards and Differentiating Types)
    
+
    유니언 타입은 값의 타입이 겹쳐질 수 있는 상황을 모델링하는데 유용합니다.
+Fish가 있는지 구체적으로 알고 싶을 때, 무슨일이 벌어질까요?
+JavaScript에서 가능한 두 값을 구분하는 흔한 방법은 멤버의 존재를 검사하는 것입니다.
+앞에서 말했듯이, 유니언 타입의 모든 구성 성분을 가지고 있다고 보장되는 멤버에만 접근할 수 있습니다.
    
 
    let pet = getSmallPet();
 
-// 이러한 각 프로퍼티 접근은 오류를 발생시킵니다.
+// 이렇게 각 프로퍼티들에 접근하는 것은 오류를 발생시킵니다
 if (pet.swim) {
     pet.swim();
 }
@@ -814,26 +924,30 @@ 
    pet.fly();
 }
 
    
-
    동일한 코드가 작동하도록 하려면 타입 단언을 사용해야 합니다 :
    
+
    같은 코드를 동작하게 하려면, 타입 단언을 사용해야 합니다:
    
 
    let pet = getSmallPet();
 
-if ((<Fish>pet).swim) {
-    (<Fish>pet).swim();
-}
-else {
-    (<Bird>pet).fly();
+if ((pet as Fish).swim) {
+    (pet as Fish).swim();
+} else if ((pet as Bird).fly) {
+    (pet as Bird).fly();
 }
 
    
-
    사용자 정의 타입 가드 (User-Defined Type Guards)
    
-
    타입 단언(type assertions)을 여러 번 사용해야 했다는 것에 주목하세요.
    일단 이 검사를 실시하면 각 지점에서 pet의 타입를 알 수 있습니다.
    
-
    그런 일이 있을 때 TypeScript에는 type guard라는 것이 있습니다.
    타입 가드(type guard)는 일부 스코프에서 타입을 보장하는 런타임 검사를 수행하는 표현식입니다.
    타입 가드를 정의하려면 반환 타입이 타입 명제 (type predicate) 인 함수를 정의하기만 하면 됩니다 :
    
+
    사용자-정의 타입 가드 (User-Defined Type Guards)
    
+
    타입 단언을 여러 번 사용한 것을 주목하세요.
+만약 검사를 실시했을 때, 각 브랜치에서 pet의 타입을 알 수 있다면 훨씬 좋을 것입니다.
    
+
    마침 TypeScript에는 타입 가드라는 것이 있습니다.
+타입 가드는 스코프 안에서의 타입을 보장하는 런타임 검사를 수행한다는 표현식입니다.
    
+
    타입 서술어 사용하기 (Using type predicates)
    
+
    타입 가드를 정의하기 위해, 반환 타입이 타입 서술어인 함수를 정의만 하면 됩니다:
    
 
    function isFish(pet: Fish | Bird): pet is Fish {
-    return (<Fish>pet).swim !== undefined;
+    return (pet as Fish).swim !== undefined;
 }
 
    
-
    pet is Fish는 이 예제에서 타입 명제입니다.
    명제는 parameterName is Type 형태을 취합니다, 여기서 parameterName은 현재 함수 시그니처의 매개 변수 이름이어야 합니다.
    
-
    IsFish가 일부 변수와 함께 호출될 때 원래 타입이 호환 가능하다면 TypeScript는 그 변수를 특정 타입으로 제한할 것입니다.
    
-
    // 'swim'과 'fly' 호출은 이제 모두 괜찮습니다.
+
    pet is Fish는 이 예제에서의 타입 서술어입니다.
+서술어는 parameterName is Type 형태이고, parameterName는 반드시 현재 함수 시그니처의 매개변수 이름이어야 합니다.
    
+
    isFish가 변수와 함께 호출될 때마다, TypeScript는 기존 타입과 호환된다면 그 변수를 특정 타입으로 제한할 것입니다.
    
+
    // 이제 'swim'과 'fly'에 대한 모든 호출은 허용됩니다
 
 if (isFish(pet)) {
     pet.swim();
@@ -842,9 +956,21 @@ 
    pet.fly();
 }
 
    
-
    TypeScript는 pet이 if 스코프의 Fish라는 것을 알고 있을 뿐만 아니라,
    else 스코프에서는 Fish가 없다는 것을 알기 때문에 Bird가 있어야 합니다.
    
+
    TypeScript가 pet이 if문 안에서 Fish라는 것을 알고 있을뿐만 아니라;
+else문 안에서 Fish가 없다는 것을 알고 있으므로, Bird를 반드시 가지고 있어야합니다.
    
+
    in 연산자 사용하기 (Using the in operator)
    
+
    in 연산자는 타입을 좁히는 표현으로 작용합니다.
    
+
    n in x 표현에서, n은 문자열 리터럴 혹은 문자열 리터럴 타입이고 x는 유니언 타입입니다. "true" 분기에서는 선택적 혹은 필수 프로퍼티 n을 가지는 타입으로 좁히고, "false" 분기에서는 선택적 혹은 누락된 프로퍼티 n을 가지는 타입으로 좁혀집니다.
    
+
    function move(pet: Fish | Bird) {
+    if ("swim" in pet) {
+        return pet.swim();
+    }
+    return pet.fly();
+}
+
    
 
    typeof 타입 가드 (typeof type guards)
    
-
    그럼 다시 돌아와 유니온 타입을 사용하는 padLeft 버전의 코드를 작성해보겠습니다.
    다음과 같이 타입 명제로 작성할 수 있습니다 :
    
+
    다시 돌아와서 유니언 타입을 사용하는 버전의 padLeft 코드를 작성해보겠습니다.
+다음과 같이 타입 서술어를 사용해서 작성할 수 있습니다:
    
 
    function isNumber(x: any): x is number {
     return typeof x === "number";
 }
@@ -863,7 +989,9 @@ 
    typeo
     throw new Error(`Expected string or number, got '${padding}'.`);
 }
 
    
-
    그러나 어떤 타입이 원시적인지 알아내는 함수를 정의하는 것은 고통스럽습니다.
    다행스럽게도, typeScript가 자체적으로 타입 가드임을 인식하기 때문에 typeof x === "number"를 직접 함수로 추상화할 필요는 없습니다.
    즉 이러한 인라인 검사를 작성할 수 있다는 것을 의미합니다.
    
+
    그러나 타입이 원시 값인지 확인하는 함수를 정의하는 것은 너무나 귀찮습니다.
+운 좋게도, TypeScript는 typeof를 타입 가드로 인식하기 때문에 typeof x === "number"를 함수로 추상할 필요가 없습니다.
+즉 타입 검사를 인라인으로 작성할 수 있습니다.
    
 
    function padLeft(value: string, padding: string | number) {
     if (typeof padding === "number") {
         return Array(padding + 1).join(" ") + value;
@@ -874,10 +1002,12 @@ 
    typeo
     throw new Error(`Expected string or number, got '${padding}'.`);
 }
 
    
-
    이것들의 typeof 타입 가드는 두가지 다른 형태로 인식됩니다: typeof v === "typename"와  typeof v !== "typename", 여기서  "typename"은 반드시 "number", "string", "boolean", 또는 "symbol".
    TypeScript에서 다른 문자열과 비교하는 것을 멈추지는 않지만 언어에서는 이러한 표현식을 타입 가드로 인식하지 않습니다.
    
+
    typeof 타입 가드는 두 가지 다른 형식인 typeof v === "typename" 와 typeof v !== "typename"이 있습니다. 여기서 typename은 "number", "string", "boolean" 그리고 "symbol"이여야 합니다.
+TypeScript에서 위에 없는 다른 문자열과 비교하는 것을 막지는 않지만, 타입 가드의 표현식으로 인지되지 않습니다.
    
 
    instanceof 타입 가드 (instanceof type guards)
    
-
    typeof 타입 가드를 읽었고 JavaScript에서 instanceof 연산자에 익숙하다면 아마 이 섹션에 대해 알 수 있을 것입니다.
    
-
    instanceof 타입 가드는 생성자 함수를 사용하여 타입을 좁히는 방법입니다.
    예를 들어, 이전의 string-padder 예제를 차용해보겠습니다:
    
+
    위의 typeof 타입 가드를 읽었고 JavaScript의 instanceof 연산자에 익숙하다면 이미 알고 있을 것입니다.
    
+
    instanceof 타입 가드 는 생성자 함수를 사용하여 타입을 좁히는 방법입니다.
+위의 string-padder 예제를 다시 보겠습니다:
    
 
    interface Padder {
     getPaddingString(): string
 }
@@ -902,35 +1032,43 @@ 
    new StringPadder("  ");
 }
 
-// 'SpaceRepeatingPadder | StringPadder' 타입입니다
+// 타입은 'SpaceRepeatingPadder | StringPadder' 입니다
 let padder: Padder = getRandomPadder();
 
 if (padder instanceof SpaceRepeatingPadder) {
-    padder; // 타입이 'SpaceRepeatingPadder'로 좁혀졌습니다
-
+    padder; // 타입은 'SpaceRepeatingPadder'으로 좁혀집니다
+}
 if (padder instanceof StringPadder) {
-    padder; // 타입이 'StringPadder'로 좁혀졌습니다.
+    padder; // 타입은 'StringPadder'으로 좁혀집니다
 }
 
    
-
    instanceof의 오른쪽에는 생성자 함수가 있어야 하며 TypeScript는 다음과 같이 범위를 좁혀 나갑니다:
    
+
    instanceof의 오른쪽은 생성자 함수여야 하며, TypeScript는 다음과 같이 좁힙니다:
    
 
      
-
    1. 타입이 any가 아닌 경우 함수의 prototype 프로퍼티 타입
      2. 
-
    2. 해당 타입의 생성자 시그니처에 의해 반환된 타입의 결합
      3. 
+
    3. 함수의 prototype 프로퍼티 타입이 any가 아닌 경우
      4. 
+
    4. 타입의 생성자 시그니처에서 반환된 유니언 타입일 경우
      5. 
 
    
-
    이와 같은 순서로 진행됩니다.
    
-
    Nullable types
    
-
    TypeScript는 null과 undefined 값을 가지는 두 가지 특별한 타입이 있습니다.
    이것을 기본 타입 섹션에서 간략하게 언급했었습니다.
    기본적으로 타입 체커는 null과 undefined를 모든 항목에 할당 가능한 것으로 간주합니다.
    사실상 null 과 undefined는 모든 타입의 유효한 값입니다.
    즉 방지하려는 경우조차도 any 타입에 할당되지 않도록 할 수 없습니다.
    null의 발명가 토니 호어는 이것을 "10억 달러의 실수"라고 부릅니다.
    
-
    --strictNullChecks에서 다음과 같이 수정할 수 있습니다: 변수를 선언할 때 자동으로 null 또는 undefined가 포함되지 않습니다.
    유니온 타입을 사용하여 명시적으로 포함할 수 있습니다:
    
+
    위와 같은 순서대로 진행됩니다.
    
+
    널러블 타입 (Nullable types)
    
+
    TypeScript는 각각 값이 null과 undefined를 갖는 특수한 타입인 null과 undefined가 있습니다.
+기본 타입에서 짧게 언급한 바 있습니다.
+기본적으로, 타입 검사 시 null과 undefined를 아무것에나 할당할 수 있다고 간주합니다.
+실제로 null과 undefined는 모든 타입에서 유효한 값입니다.
+즉, 방지하고 싶어도 어떤 타입에 할당되는 것을 방지할 없습니다.
+null의 개발자인 Tony Hoare는 이를 두고"십억 불짜리 실수 (billion dollar mistake)"라고 부릅니다.
    
+
    이건 --strictNullChecks 플래그로 해결합니다: 변수를 선언할 때, 자동으로 null이나 undefined를 포함하지 않습니다.
+유니언 타입을 사용하여 명시적으로 포함할 수 있습니다.
    
 
    let s = "foo";
-s = null; // 오류, 'null'은 'string'에 할당할 수 없습니다.
+s = null; // 오류, 'null'은 'string'에 할당할 수 없습니다
 let sn: string | null = "bar";
-sn = null; // 좋아요
+sn = null; // 성공
 
 sn = undefined; // 오류, 'undefined'는 'string | null'에 할당할 수 없습니다.
 
    
-
    TypeScript는 JavaScript의 의미론과 일치하도록 null과 undefined를 다르게 다루고 있습니다.
    string | null은 string | undefined 및 string | undefined | null과는 다른 타입입니다.
    
+
    TypeScript는 JavaScript와 맞추기 위해 null과 undefined를 다르게 처리합니다.
+string | null은 string | undefined와 string | undefined | null과는 다른 타입입니다.
    
+
    TypeScript 3.7 이후부터는 널러블 타입을 간단하게 다룰 수 있게 optional chaining를 사용할 수 있습니다.
    
 
    선택적 매개변수와 프로퍼티 (Optional parameters and properties)
    
-
    --strictNullChecks와 선택적 매개 변수는 자동으로 | undefined를 추가합니다:
    
+
    --strictNullChecks를 적용하면, 선택적 매개변수가 | undefined를 자동으로 추가합니다:
    
 
    function f(x: number, y?: number) {
     return x + (y || 0);
 }
@@ -939,20 +1077,21 @@ 
    f(1, undefined);
 f(1, null); // 오류, 'null'은 'number | undefined'에 할당할 수 없습니다
 
    
-
    선택적 프로퍼티의 경우에도 동일합니다:
    
+
    선택적 프로퍼티도 마찬가지입니다:
    
 
    class C {
     a: number;
     b?: number;
 }
 let c = new C();
 c.a = 12;
-c.a = undefined; // 오류, 'undefined'를 'number'에 할당 할 수 없습니다
+c.a = undefined; // 오류, 'undefined'는 'number'에 할당할 수 없습니다
 c.b = 13;
-c.b = undefined; // ok
-c.b = null; // 오류, 'null'은 'number | undefined'에 할당할 수 없습니다
+c.b = undefined; // 성공
+c.b = null; // 오류, 'null'은 'number | undefined'에 할당할 수 없습니다.
 
    
 
    타입 가드와 타입 단언 (Type guards and type assertions)
    
-
    nullable 타입은 유니온으로 구현되기 때문에 타입 가드를 사용하여 null을 제거해야 합니다.
    다행히 JavaScript에서 작성하는 코드는 다음과 같습니다:
    
+
    널러블 타입이 유니언으로 구현되기 때문에, null을 제거하기 위해 타입 가드를 사용할 필요가 있습니다
+다행히, JavaScript에서 작성했던 코드와 동일합니다.
    
 
    function f(sn: string | null): string {
     if (sn == null) {
         return "default";
@@ -962,15 +1101,16 @@ 
    function f(sn: string | null): string {
     return sn || "default";
 }
 
    
-
    컴파일러가 null 또는 undefined를 제거할 수 없는 경우 타입 단언 연산자를 사용하여 수동으로 제거할 수 있습니다.
    구문은 후위에 ! 입니다: identifier!는 identifier의 타입 null과 undefined를 제거합니다:
    
+
    컴파일러가 null이나 undefined를 제거할 수 없는 경우, 타입 단언 연산자를 사용하여 수동으로 제거할 수 있습니다.
+구문은 !를 후위 표기하는 방법입니다: identifier!는 null과 undefined를 identifier의 타입에서 제거합니다.
    
 
    function broken(name: string | null): string {
   function postfix(epithet: string) {
-    return name.charAt(0) + '.  the ' + epithet; // 오류, 'name'이 null일 수 있습니다.
+    return name.charAt(0) + '.  the ' + epithet; // 오류, 'name'은 아마도 null 입니다
   }
   name = name || "Bob";
   return postfix("great");
@@ -978,15 +1118,18 @@ 
    function fixed(name: string | null): string {
   function postfix(epithet: string) {
-    return name!.charAt(0) + '.  the ' + epithet; // 좋아요
+    return name!.charAt(0) + '.  the ' + epithet; // 성공
   }
   name = name || "Bob";
   return postfix("great");
 }
 
    
-
    이 예제에서 컴파일러가 중첩된 함수 내에서 null을 제거할 수 없기 때문에 여기에 중첩된 함수를 사용합니다(즉시실행함수 제외).
    특히 외부 함수에서 호출한 경우 중첩된 함수에 대한 모든 호출을 추적할 수 없기 때문입니다.
    함수가 어디에서 호출되는지 알지 못하면 body가 실행될 때 name의 타입이 무엇인지 알 수 없습니다.
    
+
    예제는 중첩 함수를 사용합니다. 왜냐하면 컴파일러가 중첩 함수안에서는 null을 제거할 수 없기 때문입니다 (즉시-호출된 함수 표현은 예외).
+특히 외부 함수에서 호출될 경우, 중첩 함수에 대한 모든 호출을 추적할 수 없기 때문입니다.
+함수가 어디에서 호출되었는지 알 수 없으면, 본문이 실행될 때 name의 타입을 알 수 없습니다.
    
 
    타입 별칭 (Type Aliases)
    
-
    타입 aliases는 타입의 새로운 이름을 생성합니다.
    타입 aliases은 인터페이스와 유사하지만 원시 타입, 유니온, 튜플 및 기타 직접 작성해야 하는 다른 타입의 이름을 지정할 수 있습니다.
    
+
    타입 별칭은 타입의 새로운 이름을 만듭니다.
+타입 별칭은 때때로 인터페이스와 유사합니다만, 원시 값, 유니언, 튜플 그리고 손으로 작성해야 하는 다른 타입의 이름을 지을 수 있습니다.
    
 
    type Name = string;
 type NameResolver = () => string;
 type NameOrResolver = Name | NameResolver;
@@ -999,18 +1142,19 @@ 
    타입 별
     }
 }
 
    
-
    Aliasing(Type Aliases)은 실제로 새로운 타입을 생성하지는 않습니다 - 그 타입을 참조하기 위해 새로운 이름을 생성합니다.
    원시 값을 Aliasing 하는 것은 문서의 형태로 사용될 수 있지만 굉장히 유용하지 않습니다.
    
-
    인터페이스와 마찬가지로 타입 aliases도 일반적일 수 있습니다 - aliases 선언의 오른쪽에 타입 매개 변수를 추가하여 사용하면 됩니다:
    
+
    별칭은 실제로 새로운 타입을 만드는 것은 아닙니다 - 그 타입을 나타내는 새로운 이름 을 만드는 것입니다.
+원시 값의 별칭을 짓는 것은 문서화의 형태로 사용할 수 있지만, 별로 유용하지 않습니다.
    
+
    인터페이스처럼, 타입 별칭은 제네릭이 될 수 있습니다 - 타입 매개변수를 추가하고 별칭 선언의 오른쪽에 사용하면 됩니다:
    
 
    type Container<T> = { value: T };
 
    
-
    type alias를 프로퍼티에서 참조할 수도 있습니다:
    
+
    프로퍼티 안에서 자기 자신을 참조하는 타입 별칭을 가질 수 있습니다:
    
 
    type Tree<T> = {
     value: T;
     left: Tree<T>;
     right: Tree<T>;
 }
 
    
-
    교차(intersection) 타입과 함께 mind-bending 타입을 만들 수 있습니다:
    
+
    교차 타입과 같이 사용하면, 아주 놀라운 타입을 만들 수 있습니다.
    
 
    type LinkedList<T> = T & { next: LinkedList<T> };
 
 interface Person {
@@ -1023,12 +1167,14 @@ 
    타입 별
 var s = people.next.next.name;
 var s = people.next.next.next.name;
 
    
-
    그러나 타입 alias가 선언의 다른 오른쪽에 나타나는 것은 불가능합니다:
    
+
    하지만, 타입 별칭을 선언의 오른쪽 이외에 사용하는 것은 불가능합니다.
    
 
    type Yikes = Array<Yikes>; // 오류
 
    
-
    Interfaces vs. Type Aliases
    
-
    앞서 언급했듯이, 타입 type aliases는 인터페이스와 같은 역할을 할 수 있지만 몇 가지 미묘한 차이점이 있습니다.
    
-
    한가지 다른 점은 인터페이스가 어디에서나 사용되는 새로운 이름을 만들어 낸다는 것입니다.
    타입 aliases는 새로운 이름을 만들지 않습니다— 예를 들어 오류 메시지는 alias 이름을 사용하지 않습니다.
    아래 코드에서, 에디터의 interfaced 위로 마우스를 가져가면 Interface를 반환할 것을 보여주지만 aliased는 객체 리터럴 타입을 반환한다는 것을 보여줍니다.
    
+
    인터페이스 vs. 타입 별칭 (Interfaces vs. Type Aliases)
    
+
    위에서 언급했듯이, 타입 별칭은 인터페이스와 같은 역할을 할 수 있습니다; 하지만, 약간의 미묘한 차이가 있습니다
    
+
    한 가지 차이점은 인터페이스는 어디에서나 사용할 수 있는 새로운 이름을 만들 수 있습니다.
+타입 별칭은 새로운 이름을 만들지 못합니다 — 예를 들어, 오류 메시지는 별칭 이름을 사용하지 않습니다.
+아래의 코드에서, 에디터에서 interfaced에 마우스를 올리면  Interface를 반환한다고 보여주지만 aliased는 객체 리터럴 타입을 반환한다고 보여줍니다.
    
 
    type Alias = { num: number }
 interface Interface {
     num: number;
@@ -1036,9 +1182,13 @@ 
    Interfaces vs. Type Aliases
    
 declare function aliased(arg: Alias): Alias;
 declare function interfaced(arg: Interface): Interface;
 
    
-
    두 번째 더 중요한 차이점은 타입 aliases를 다음에서 확장하거나 구현할 수 없다는 것입니다 (다른 타입을 확장/구현할 수도 없습니다).
    왜냐하면 소프트웨어의 이상적인 특성이 확장에 열려있다 가능한 경우 타입 alias에 대한 인터페이스를 사용해야 합니다.
    다른 한편으로는, 인터페이스로 일부 형태를 표현할 수 없고 유니온이나 튜플 타입을 사용해야 하는 경우 타입 aliases을 사용하는 것이 보통 좋습니다.
    
+
    TypeScript의 이전 버전에서, 타입 별칭은 extend 하거나 implement 할 수 없었습니다 (다른 타입을 extend/implement 할 수도 없습니다). 2.7 버전부터, 타입 별칭은 교차 타입을 생성함으로써 extend 할 수 있습니다. 예를 들어, type Cat = Animal & { purrs: true }.
    
+
    소프트웨어의 이상적인 특징은 확장에 개방되어 있기 때문에, 가능하면 항상 타입 별칭보다 인터페이스를 사용해야 합니다.
    
+
    반면에, 만약 인터페이스로 어떤 형태를 표현할 수 없고 유니언이나 튜플 타입을 사용해야 한다면, 일반적으로 타입 별칭을 사용합니다.
    
 
    문자열 리터럴 타입 (String Literal Types)
    
-
    문자열 리터럴 타입을 사용하여 문자열에 필요한 정확한 값을 지정할 수 있습니다.
    실제로 문자열 리터럴 타입은 유니온 타입, 타입 가드 및 타입 aliases와 잘 결합됩니다.
    이러한 기능을 함께 사용하여 문자열에서 열거형과 같은 동작을 얻을 수 있습니다.
    
+
    문자열 리터럴 타입은 문자열에 값을 정확하게 지정할 수 있게 해줍니다.
+예제에서 문자열 리터럴 타입은 유니언 타입, 타입 가드, 그리고 타입 별칭과 잘 결합됩니다.
+이 기능을 열거형-같은 행동을 문자열과 함께 사용할 수 있습니다.
    
 
    type Easing = "ease-in" | "ease-out" | "ease-in-out";
 class UIElement {
     animate(dx: number, dy: number, easing: Easing) {
@@ -1050,50 +1200,53 @@ 
    else if (easing === "ease-in-out") {
         }
         else {
-            // 오류! null 또는 undefined로 통과해서는 안 됩니다.
+            // 오류! null이나 undefined를 전달하면 안됩니다
         }
     }
 }
 
 let button = new UIElement();
 button.animate(0, 0, "ease-in");
-button.animate(0, 0, "uneasy"); // 오류: 여기서 "uneasy"가 허용되지 않습니다.
+button.animate(0, 0, "uneasy"); // 오류: "uneasy"는 여기서 허용하지 않습니다
 
    
-
    허용되는 세 문자열 중 아무거나 전달할 수 있지만 다른 문자열은 오류를 제공합니다.
    
-
    '"uneasy"' 타입의 인수를 타입의 매개 변수에 지정할 수 없습니다. '"ease-in" | "ease-out" | "ease-in-out"'
+
    허용되는 3개의 문자열 아무거나 전달할 수 있지만, 그 외 다른 문자열들은 오류를 발생시킵니다.
    
+
    Argument of type '"uneasy"' is not assignable to parameter of type '"ease-in" | "ease-out" | "ease-in-out"'
 
    
-
    오버로드를 구별하기 위해 동일한 방법으로 문자열 리터럴 타입을 사용할 수 있습니다.
    
+
    문자열 리터럴 타입은 오버로드를 구별하기 위해 같은 방법으로 사용할 수 있습니다.
    
 
    function createElement(tagName: "img"): HTMLImageElement;
 function createElement(tagName: "input"): HTMLInputElement;
 // ... 더 많은 오버로드 ...
 function createElement(tagName: string): Element {
-    // ... 코드는 여기에 있습니다 ...
+    // ... 이곳에 코드를 ...
 }
 
    
 
    숫자 리터럴 타입 (Numeric Literal Types)
    
-
    TypeScript에는 숫자 리터럴 타입도 있습니다.
    
-
    function rollDie(): 1 | 2 | 3 | 4 | 5 | 6 {
+
    TypeScript는 또한 숫자 리터럴 타입을 갖고 있습니다.
    
+
    function rollDice(): 1 | 2 | 3 | 4 | 5 | 6 {
     // ...
 }
 
    
-
    이들은 명시적으로 작성되는 경우는 거의 없으며 범위를 좁히는 것이 버그를 잡는 데 유용할 수 있습니다:
    
+
    명시적으로 작성되는 경우는 거의 없지만, 이슈를 좁히고 버그를 잡는데 유용할 수 있습니다.
    
 
    function foo(x: number) {
     if (x !== 1 || x !== 2) {
         //         ~~~~~~~
-        // 연산자 '!=='는 '1'과 '2' 타입에는 적용 할 수 없습니다.
+        // '!==' 연산자는 '1'과 '2' 타입에 적용할 수 없습니다.
     }
 }
 
    
-
    바꿔 말하면 x는 2와 비교할 때 1이어야 하며 이것은 위 체크가 유효하지 않은 비교를 하고 있음을 의미합니다.
    
+
    다시 말하면, x는 2와 비교될 때, 반드시 1이어야 하는데 위의 검사가 유효하지 않은 비교를 의미합니다.
    
 
    열거형 멤버 타입 (Enum Member Types)
    
-
    열거형 섹션에서 언급했듯이 열거형 멤버는 모든 멤버가 리터럴로 초기화될 때 타입을 가집니다.
    
-
    "싱글톤 타입"에 대해 이야기할 때 많은 시간 동안, 많은 사용자가 "싱글톤 타입"과 "리터럴 타입"을 바꿔 사용하겠지만 숫자/문자열 리터럴 타입뿐만 아니라 열거형 멤버 타입을 모두 참조합니다
    
-
    유니온 식별 (Discriminated Unions)
    
-
    싱글톤 타입, 유니온 타입, 타입 가드 및 타입 별칭을 결합하여 discriminated unions, tagged unions 또는 대수의(algebraic) 데이터 타입라는 고급 패턴을 빌드할 수 있습니다.
    Discriminated unions은 함수형 프로그래밍에 유용합니다.
    일부 언어는 자동으로 discriminate unions합니다; TypeScript는 현재 존재하는 JavaScript 패턴을 기반으로 합니다.
    세가지 구성요소가 있습니다:
    
+
    열거형 섹션에서 언급했듯이, 열거형 멤버는 모든 멤버가 리터럴로-초기화될 때 타입을 가집니다.
    
+
    싱글톤 타입을 이야기 할때 여기서는 열거형 멤버 타입과 숫자/문자열 리터럴 타입을 얘기하지만, 대부분 많은 유저들은 "싱글톤 타입"과 "리터럴 타입"을 상호 교환적으로 사용합니다.
    
+
    판별 유니언 (Discriminated Unions)
    
+
    태그 된 유니언 또는 대수적 데이터 타입이라고도 하는 판별 유니언 고급 패턴을 만들기 위해서 싱글톤 타입, 유니언 타입, 타입 가드, 타입 별칭을 합칠 수 있습니다.
+판별 유니언은 함수형 프로그래밍에서 유용합니다.
+어떤 언어에서는 자동으로 판별 유니언을 제공합니다; TypeScript는 대신에 현재 JavaScript 패턴을 기반으로 합니다.
+세 가지 요소가 있습니다:
    
 
      
-
    1. 공통적인 싱글톤 타입의 특성을 갖는 타입 — discriminant.
      2. 
-
    2. 이러한 타입의 합집합을 취하는 타입 별칭 — union.
      3. 
-
    3. 공통 프로퍼티에 타입 가드.
      4. 
+
    4. 공통 싱글톤 타입 프로퍼티를 갖는 타입 — 판별식.
      5. 
+
    5. 해당 타입들의 유니언을 갖는 타입 별칭 — 유니언.
      6. 
+
    6. 공통 프로퍼티의 타입 가드
      7. 
 
    
 
    interface Square {
     kind: "square";
@@ -1109,10 +1262,15 @@ 
    유
     radius: number;
 }
 
    
-
    먼저 결합할 인터페이스를 선언합니다.
    각 인터페이스는 다른 문자열 리터럴 타입을 가진 kind 프로퍼티를 가지고 있습니다.
    kind 프로퍼티는 discriminant 또는 tag라고 부릅니다.
    다른 프로퍼티는 각 인터페이스에 고유합니다.
    인터페이스는 현재 관련이 없습니다.
    그것들을 결합하여 넣습니다:
    
+
    먼저 통합할 인터페이스를 선언합니다.
+각 인터페이스는 다른 문자열 리터럴 타입의 kind 프로퍼티를 가집니다.
+kind 프로퍼티는 판별식 혹은 태그라고 부릅니다.
+다른 프로퍼티는 각 인터페이스에 따라 다릅니다.
+현재 인터페이스는 관련이 없다는 것에 유의하세요.
+이제 유니언으로 집어넣어 봅시다:
    
 
    type Shape = Square | Rectangle | Circle;
 
    
-
    이제 식별 유니온을 사용합니다:
    
+
    이제 판별 유니언을 사용해보겠습니다:
    
 
    function area(s: Shape) {
     switch (s.kind) {
         case "square": return s.size * s.size;
@@ -1121,8 +1279,9 @@ 
    유
     }
 }
 
    
-
    철저한 검사 (Exhaustiveness checking)
    
-
    식별 유니온의 모든 변형을 다루지 않을 때 컴파일러에서 알려주면 좋겠습니다.
    예를 들어 Shape에 Triangle을 추가하면 area도 업데이트해야 합니다:
    
+
    엄격한 검사 (Exhaustiveness checking)
    
+
    판별 유니언의 모든 변형을 커버할 수 없을 때, 컴파일러가 알려주길 원합니다.
+예를 들어, 만약 Triangle을 Shape에 추가하면, area도 업데이트해야 합니다.
    
 
    type Shape = Square | Rectangle | Circle | Triangle;
 function area(s: Shape) {
     switch (s.kind) {
@@ -1130,12 +1289,12 @@ 
    Ì
         case "rectangle": return s.height * s.width;
         case "circle": return Math.PI * s.radius ** 2;
     }
-    // 여기서 오류가 발생해야합니다 - "triangle"을 핸들링하지 않았습니다
+    // 여기서 오류 발생 - "triangle"의 케이스를 처리하지 않음
 }
 
    
-
    두 가지 방법이 있습니다.
-첫 번째는 --strictNullChecks를 켜고 반환 타입을 지정하는 것입니다 :
    
-
    function area(s: Shape): number { // 오류: returns number | undefined
+
    이를 해결하기 위해 두 가지 방법이 있습니다.
+첫 번째는 --strictNullChecks를 키고 반환 타입을 지정하는 것입니다.
    
+
    function area(s: Shape): number { // 오류: number | undefined를 반환합니다
     switch (s.kind) {
         case "square": return s.size * s.size;
         case "rectangle": return s.height * s.width;
@@ -1143,8 +1302,10 @@ 
    Ì
     }
 }
 
    
-
    switch가 더 이상 완전하지 않기 때문에 TypeScript는 그 함수가 때때로 undefined를 반환할 수 있다는 것을 알고 있습니다.
    명시적 반환 타입 number를 가지고 있다면 반환 타입이 실제로 number | undefined라는 오류가 발생합니다.
    그러나 이 방법은 매우 미묘하며 --strictNullChecks가 오래된 코드에서 항상 작동하는 것은 아닙니다.
    
-
    두 번째 방법은 컴파일러가 철저히 검사하기 위해 never 타입을 사용한다는 점입니다.
    
+
    switch가 더 이상 철저하지 않아서 TypeScript는 함수가 undefined를 반환할 수 있다는 것을 알고 있습니다.
+만약 명시적인 반환 타입 number를 가지고 있으면, 반환 타입이 실제로 number | undefined라는 오류를 얻게 됩니다.
+하지만 이 방법은 꽤 애매하고 --strictNullChecks가 예전 코드에서 항상 작동하는 것은 아닙니다.
    
+
    두 번째 방법은 컴파일러가 완전함을 검사하기 위해 사용하는 never 타입을 사용하는 것입니다.
    
 
    function assertNever(x: never): never {
     throw new Error("Unexpected object: " + x);
 }
@@ -1153,14 +1314,18 @@ 
    Ì
         case "square": return s.size * s.size;
         case "rectangle": return s.height * s.width;
         case "circle": return Math.PI * s.radius ** 2;
-        default: return assertNever(s); // 누락된 경우 여기에 오류가 발생합니다
+        default: return assertNever(s); // 빠진 케이스가 있다면 여기서 오류 발생
     }
 }
 
    
-
    여기서, assertNever는 s가 never 타입인지 확인합니다 — 다른 모든 case가 종료된 후에 남겨진 타입이 제거되었습니다.
    case를 잊어버리면 s가 실제 타입을 가지게되고 타입 에러가 생깁니다.
    이 방법을 사용하려면 추가 함수을 정의해야 하지만 잊어버렸을 때 훨씬 더 분명해집니다.
    
-
    다형성의 this 타입 (Polymorphic this types)
    
-
    다형성의this 타입은 포함된 클래스나 인터페이스의 서브타입 타입을 나타냅니다.
    이것을 F-바운드 다형성이라고 합니다.
-따라서 계층적으로 완만한 인터페이스를 훨씬 쉽게 표현할 수 있습니다.
    각각의 연산자에 this를 반환하는 간단한 계산기가 있습니다:
    
+
    여기서, assertNever는 s가 never 타입인지 검사합니다 — 모든 다른 케이스들이 제거된 후 남은 타입.
+만약 케이스를 잊었다면, s는 실제 타입을 가질 것이고 타입 오류가 발생합니다.
+이 방법은 추가 함수를 정의해야 합니다만 잊어버렸을 때, 훨씬 더 명백해집니다.
    
+
    다형성 this 타입 (Polymorphic this types)
    
+
    다형성 this 타입은 포함하는 클래스나 인터페이스의 하위 타입을 나타냅니다.
+F-bounded polymorphism이라고 부릅니다.
+예를 들어, 계층적으로 유연한 인터페이스를 표현하기 더 쉽게 만듭니다.
+각 연산 후에 this를 반환하는 간단한 계산기를 보겠습니다:
    
 
    class BasicCalculator {
     public constructor(protected value: number = 0) { }
     public currentValue(): number {
@@ -1174,7 +1339,7 @@ 
    this.value *= operand;
         return this;
     }
-    // ... 다른 연산은 여기에 있습니다 ...
+    // ... 다른 연산들은 여기에 작성 ...
 }
 
 let v = new BasicCalculator(2)
@@ -1182,7 +1347,7 @@ 
    add(1)
             .currentValue();
 
    
-
    클래스는 this 타입을 사용하기 때문에 확장할 수 있으며 새로운 클래스는 변경 없이 이전 메서드를 사용할 수 있습니다.
    
+
    클래스가 this 타입을 사용하기 때문에, 이를 extend 할 수 있고 새로운 클래스가 아무 변경 없이 이전 메서드를 사용할 수 있습니다.
    
 
    class ScientificCalculator extends BasicCalculator {
     public constructor(value = 0) {
         super(value);
@@ -1191,7 +1356,7 @@ 
    this.value = Math.sin(this.value);
         return this;
     }
-    // ... 다른 연산은 여기에 있습니다 ...
+    // ... 다른 연산들은 여기에 작성 ...
 }
 
 let v = new ScientificCalculator(2)
@@ -1200,73 +1365,109 @@ 
    add(1)
         .currentValue();
 
    
-
    this 타입이 없었다면 ScientificCalculator는 BasicCalculator를 확장하지도 못하고 완만한 인터페이스를 유지할 수 없었을 것입니다.
    multiply는 sin 메서드가 없는BasicCalculator를 반환했을 것입니다.
    그러나 this 타입의 경우 multiply는 this를 리턴합니다. this는 ScientificCalculator입니다.
    
+
    this 타입 없이, ScientificCalculator는 BasicCalculator를 extend 할 수 없을 것이고 유연한 인터페이스를 유지하지 못할 것입니다.
+multiply는 sin 메서드를 가지지 않는 BasicCalculator를 반환합니다.
+하지만, this 타입으로, multiply는 this를 반환하고, 여기서는 ScientificCalculator을 말합니다.
    
 
    인덱스 타입 (Index types)
    
-
    인덱스 타입을 사용하면 동적 프로퍼티 이름을 사용하는 코드를 컴파일러가 검사하도록 할 수 있습니다.
-예를 들어 일반적인 Javascript 패턴은 객체에서 프로퍼티의 하위 집합을 선택하는 것입니다:
    
-
    function pluck(o, names) {
-    return names.map(n => o[n]);
+
    인덱스 타입을 사용하면, 동적인 프로퍼티 이름을 사용하는 코드를 컴파일러가 검사할 수 있습니다.
+예를 들어, 일반적인 JavaScript 패턴은 객체에서 프로퍼티의 부분집합을 뽑아내는 것입니다:
    
+
    function pluck(o, propertyNames) {
+    return propertyNames.map(n => o[n]);
 }
 
    
-
    다음은 인덱스 타입 쿼리 및 인덱스 접근 연산자를 사용하여 TypeScript에서 이 함수를 작성하고 사용하는 방법입니다.
    
-
    function pluck<T, K extends keyof T>(o: T, names: K[]): T[K][] {
-  return names.map(n => o[n]);
+
    여기서는 인덱스 타입 쿼리와 인덱스 접근 연산자를 사용해서 TypeScript에서 이 함수를 어떻게 작성하고 사용하는지 보여줍니다:
    
+
    function pluck<T, K extends keyof T>(o: T, propertyNames: K[]): T[K][] {
+  return propertyNames.map(n => o[n]);
 }
 
-interface Person {
-    name: string;
-    age: number;
+interface Car {
+    manufacturer: string;
+    model: string;
+    year: number;
 }
-let person: Person = {
-    name: 'Jarid',
-    age: 35
+let taxi: Car = {
+    manufacturer: 'Toyota',
+    model: 'Camry',
+    year: 2014
 };
-let strings: string[] = pluck(person, ['name']); // 좋아요, string[]
+
+// Manufacturer과 model은 둘 다 문자열 타입입니다,
+// 그래서 둘 다 타이핑된 문자열 배열로 끌어낼 수 있습니다.
+let makeAndModel: string[] = pluck(taxi, ['manufacturer', 'model']);
+
+// 만약 model과 year를 끌어내려고 하면,
+// 유니언 타입의 배열: (string | number)[] 을 얻게됩니다.
+let modelYear = pluck(taxi, ['model', 'year'])
 
    
-
    컴파일러는 name이 실제로 Person의 프로퍼티인지 확인합니다.
    이 예제는 몇 가지 새로운 타입의 연산자를 소개합니다.
-첫 번째는 keyof T으로 인덱스 타입 쿼리 연산자입니다.
    어떤 타입의 T에 대해서 keyof T는 T의 알려진 public 프로퍼티 이름들의 유니온입니다.
    
-
    예를 들어:
    
-
    let personProps: keyof Person; // 'name' | 'age'
+
    컴파일러는 manufacturer 와 model이 실제 Car의 프로퍼티인지 검사합니다.
+예제는 몇 가지 새로운 타입 연산자를 소개합니다.
+첫 번째, keyof T는 인덱스 타입 쿼리 연산자입니다.
+any 타입인 T, keyof T는 T의 알려지고 공개된 프로퍼티 이름들의 유니언입니다.
+예를 들어:
    
+
    let carProps: keyof Car; // ('manufacturer' | 'model' | 'year')의 유니언
 
    
-
    keyof Person은 'name' | 'age'와 완전히 호환됩니다.
    차이점은 Person에 또 다른 프로퍼티인 address: string을 추가하면 keyof Person은 자동으로 'name' | 'age' | 'address'로 업데이트된다는 점이다.
    그리고 pluck과 같은 일반적인 컨텍스트에서 keyof를 사용할 수 있으며 이때 프로퍼티 이름을 미리 알 수는 없습니다.
    즉 컴파일러가 올바른 프로퍼티 이름을 pluck으로 전달했는지 확인합니다:
    
-
    pluck(person, ['age', 'unknown']); // 오류, 'unknown'은 'name' | 'age'에 없습니다
+
    keyof Car는 'manufacturer' | 'model' | 'year'와 완전히 호환됩니다.
+차이점은 Car에 ownersAddress: string라는 또 다른 프로퍼티를 추가한다면, keyof Car는 자동으로 'manufacturer' | 'model' | 'year' | 'ownersAddress'로 업데이트합니다.
+그리고 미리 프로퍼티 이름을 알 수 없을 때, pluck처럼 제네릭 컨텍스트에서 keyof를 사용할 수 있습니다.
+즉 컴파일러가 올바른 프로퍼티 이름들의 집합을 pluck에 전달하는지 검사합니다:
    
+
    // 오류, 'manufacturer' | 'model' | 'year'에 'unknown'이 없습니다.
+pluck(taxi, ['year', 'unknown']); /
 
    
-
    두 번째 연산자는 T[K], 인덱스 접근 연산자(indexed access operator) 입니다.
    
-
    여기서 타입의 구문은 표현식을 반영합니다.
    
-
    즉 person['name']은 Person['name']타입을 가집니다 —
-예제에서는 단지 string입니다.
    
-
    하지만 인덱스 타입 쿼리와 마찬가지로 T[K]를 사용하면 실질적으로 힘이 발휘되는 일반적인 컨텍스트에서 사용할 수 있습니다.
    타입 변수 K extends keyof T를 확실히 만들어야 합니다.
    여기 getProperty라는 함수가 있는 또 다른 예제가 있습니다.
    
-
    function getProperty<T, K extends keyof T>(o: T, name: K): T[K] {
-    return o[name]; // o[name]은 T[K] 타입입니다
+
    두 번째 연산자는 인덱스 접근 연산자 T[K]입니다.
+여기서, 타입 구문은 표현 구문을 반영합니다.
+즉 person['name']은 Person['name'] 타입 — 이 예제에서는 단지 string, 을 가집니다.
+하지만, 인덱스 타입 쿼리처럼, T[K]를 제네릭 컨텍스트에서 사용할 수 있습니다.
+타입 변수 K extends keyof T인지 확인하면 됩니다.
+여기 getProperty 함수의 또 다른 예제가 있습니다.
    
+
    function getProperty<T, K extends keyof T>(o: T, propertyName: K): T[K] {
+    return o[propertyName]; // o[propertyName]는 T[K] 타입입니다
 }
 
    
-
    getProperty에서, o: T와 name: K는 o[name]: T[K]를 의미합니다.
    일단 T[K] 결과를 반환하면 컴파일러는 실제 키의 타입을 인스턴스화하므로 getProperty의 반환 타입은 사용자가 요청하는 프로퍼티에 따라 달라집니다.
    
-
    let name: string = getProperty(person, 'name');
-let age: number = getProperty(person, 'age');
-let unknown = getProperty(person, 'unknown'); // 오류, 'unknown'은 'name' | 'age'에 없습니다
+
    getProperty, o: T 그리고 propertyName: K은 o[propertyName]: T[K]를 의미합니다.
+T[K] 결과를 반환하면, 컴파일러는 실제 키의 타입을 인스턴스화하고, getProperty의 반환 타입은 요청한 프로퍼티에 따라 달라집니다.
    
+
    let name: string = getProperty(taxi, 'manufacturer');
+let year: number = getProperty(taxi, 'year');
+
+// 오류, 'unknown'은 'manufacturer' | 'model' | 'year'에 없습니다
+let unknown = getProperty(taxi, 'unknown');
 
    
-
    인덱스 타입과 문자열 인덱스 시그니처 (Index types and string index signatures)
    
-
    keyof와 T[K]는 문자열 인덱스 시그니처과 상호 작용합니다.
    문자열 인덱스 시그니처을 가진 타입을 가지고 있다면 keyof T는 단지string이 될 것입니다.
    그리고 T[string]은 인덱스 시그니처의 한가지 종류일뿐입니다:
    
-
    interface Map<T> {
+
    인덱스 타입과 인덱스 시그니처 (Index types and index signatures)
    
+
    keyof와 T[K]가 인덱스 시그니처와 상호 작용합니다. 인덱스 시그니처 매개변수 타입은 'string' 혹은 'number'이어야 합니다.
+만약 문자열 인덱스 시그니처인 타입이 있으면, keyof T는 string | number가 될 것입니다
+(그냥 string이 아닙니다, JavaScript에선 문자열 (object['42'])나 숫자 (object[42])를 사용해서
+객체 프로퍼티에 접근할 수 있습니다).
+그리고 T[string]은 인덱스 시그니처의 타입입니다:
    
+
    interface Dictionary<T> {
     [key: string]: T;
 }
-let keys: keyof Map<number>; // string
-let value: Map<number>['foo']; // number
+let keys: keyof Dictionary<number>; // string | number
+let value: Dictionary<number>['foo']; // number
 
    
-
    Mapped types
    
-
    일반적인 작업은 기존 타입을 선택하고 각 프로퍼티를 선택적으로 만드는 것입니다:
    
+
    숫자 인덱스 시그니처인 타입이 있으면, keyof T는 number일 것입니다.
    
+
    interface Dictionary<T> {
+    [key: number]: T;
+}
+let keys: keyof Dictionary<number>; // 숫자
+let value: Dictionary<number>['foo']; // 오류, 프로퍼티 'foo'는 타입 'Dictionary<number>'에 존재하지 않습니다.
+let value: Dictionary<number>[42]; // 숫자
+
    
+
    매핑 타입 (Mapped types)
    
+
    기존 타입을 가져와 선택적 프로퍼티로 만드는 것은 일반적인 작업입니다:
    
 
    interface PersonPartial {
     name?: string;
     age?: number;
 }
 
    
-
    또는 readonly를 원할 수도 있습니다.
    
+
    혹은 읽기전용 버전을 원할 수도 있습니다:
    
 
    interface PersonReadonly {
     readonly name: string;
     readonly age: number;
 }
 
    
-
    이러한 일은 Javascript에서 자주 발생하여 TypeScript는 이전 타입인 — mapped types 타입을 기반으로 새로운 타입을 만드는 방법을 제공합니다.
    mapped type에서 새로운 타입은 이전 타입의 각 프로퍼티를 동일한 방식으로 변환합니다.
    예를 들어 모든 프로퍼티 타입을 readonly 또는 선택적으로 설정할 수 있습니다.
    아래 몇 가지 예제가 있습니다:
    
+
    JavaScript에서 충분히 자주 일어나는 일이며 TypeScript는 이전 타입 — 매핑 타입을 기반으로 새로운 타입을 만드는 방법을 제공합니다.
+매핑 타입에서, 새로운 타입은 이전 타입에서 각 프로퍼티를 같은 방법으로 변환합니다.
+예를 들어, 모든 프로퍼티를 readonly 혹은 선택적으로 만들수 있습니다.
+여기 몇가지 예제가 있습니다:
    
 
    type Readonly<T> = {
     readonly [P in keyof T]: T[P];
 }
@@ -1274,35 +1475,57 @@ 
    Mapped types
    
     [P in keyof T]?: T[P];
 }
 
    
-
    그리고 그것을 사용하려면:
    
+
    그리고 사용하기 위해서는:
    
 
    type PersonPartial = Partial<Person>;
 type ReadonlyPerson = Readonly<Person>;
 
    
-
    가장 간단한 mapped type과 해당 부분을 살펴보겠습니다:
    
+
    이 구문이 멤버보다는 타입을 설명한다는 것에 유의하세요.
+멤버를 추가하길 원한다면, 교차 타입을 사용할 수 있습니다:
    
+
    // Use this:
+type PartialWithNewMember<T> = {
+  [P in keyof T]?: T[P];
+} & { newMember: boolean }
+
+// 다음을 사용하지 **마세요**!
+// 오류입니다!
+type PartialWithNewMember<T> = {
+  [P in keyof T]?: T[P];
+  newMember: boolean;
+}
+
    
+
    가장 간단한 매핑 타입과 그 부분을 봅시다:
    
 
    type Keys = 'option1' | 'option2';
 type Flags = { [K in Keys]: boolean };
 
    
-
    구문은 인덱스 시그니처을 위한 구문과 for .. in 내부가 유사하게 사용됩니다.
    세 가지 파트로 나뉩니다:
    
+
    구문은 for .. in이 들어간 인덱스 시그니처 구문과 유사합니다.
+세 부분으로 나뉩니다:
    
 
      
-
    1. 변수의 타입 K는 각 프로퍼티에 차례대로 바인딩 됩니다.
      2. 
-
    2. 문자열 리터럴 유니온 Keys는 반복할 프로퍼티의 이름을 포함합니다.
      3. 
-
    3. 결과적으로 생성된 프로퍼티의 타입.
      4. 
+
    4. 각 프로퍼티에 순서대로 바인딩되는 타입 변수 K.
      5. 
+
    5. 반복할 프로퍼티 이름이 포함된 문자열 리터럴 유니언 Keys.
      6. 
+
    6. 프로퍼티의 결과 타입
      7. 
 
    
-
    이 간단한 예제에서 Keys는 하드 코딩된 프로퍼티 이름의 리스트이고 프로퍼티 타입은 항상 boolean이므로 mapped type은 작성된 것과 같습니다.
    
+
    이 간단한 예제에서, Keys는 하드-코딩된 프로퍼티 이름 목록이고 프로퍼티 타입은 항상 boolean입니다, 그래서 이 매핑 타입은 아래 쓰인 것과 동일합니다:
    
 
    type Flags = {
     option1: boolean;
     option2: boolean;
 }
 
    
-
    그러나 실제 애플리케이션은 위의 Readonly 또는 Partial처럼 보입니다.
    기존의 타입을 기반으로 하며 어떤 방식으로든 필드를 변환합니다.
    즉 keyof와 인덱스 접근 타입이 들어있는 곳입니다:
    
+
    하지만 실제 애플리케이션은, 위에서 readonly나 Partial처럼 보입니다.
+존재하는 타입을 기반으로 하고, 특정 방법으로 프로퍼티를 변형시킵니다.
+이때 keyof와 인덱스 접근 타입이 등장합니다:
    
 
    type NullablePerson = { [P in keyof Person]: Person[P] | null }
 type PartialPerson = { [P in keyof Person]?: Person[P] }
 
    
-
    하지만 일반적인 버전을 사용하는 것이 더 유용합니다.
    
+
    하지만 일반적인 버전을 가지는 게 더 유용할 것입니다.
    
 
    type Nullable<T> = { [P in keyof T]: T[P] | null }
 type Partial<T> = { [P in keyof T]?: T[P] }
 
    
-
    이 예제에서 프로퍼티 목록은 keyof T이며 결과 타입은 T[P]의 변형입니다.
    이것은 mapped types의 일반적인 사용을 위한 좋은 템플릿입니다.
    왜냐하면 이러한 종류의 변환은 유사 동형(homomorphic)이기 때문에 매핑은 T의 프로퍼티에만 적용되고 다른 프로퍼티에는 적용되지 않습니다.
    컴파일러는 새로운 프로퍼티를 추가하기 전에 기존의 프로퍼티 지정자를 모두 복사할 수 있다는 것을 알고 있습니다.
    예를 들어 Person.name이 읽기 전용인 경우 Partial<Person>.name은 읽기 전용 및 선택적입니다.
    다음은 T[P]가 Proxy<T> 클래스에 래핑된 또 하나의 예제입니다:
    
+
    이 예제들에서, 프로퍼티 목록은 keyof T이고 결과 타입은 T[P]의 변형입니다.
+이는 매핑 타입의 일반적인 사용에 있어 좋은 템플릿입니다.
+왜냐하면 이런 종류의 변형이 동형 (homomorphic) 이기 때문에, 매핑이 T의 프로퍼티에만 적용되고 다른 것에는 적용되지 않습니다.
+컴파일러는 새로운 것을 추가하기 전에 존재하는 모든 프로퍼티 지정자를 복사할 수 있다는 것을 알고 있습니다.
+예를 들어, 만약 Person.name이 읽기 전용이었다면, Partial<Person>.name은 읽기 전용이고 선택적일 것입니다.
    
+
    Proxy<T> 클래스 안에 래핑 된 T[P]에 대한 예제가 하나 더 있습니다.
    
 
    type Proxy<T> = {
     get(): T;
     set(value: T): void;
@@ -1311,24 +1534,26 @@ 
    Mapped types
    
     [P in keyof T]: Proxy<T[P]>;
 }
 function proxify<T>(o: T): Proxify<T> {
-   // ... proxies 감싸기 ...
+   // ... 프록시 래핑 ...
 }
 let proxyProps = proxify(props);
 
    
-
    Readonly<T>와 Partial<T>는 매우 유용하기 때문에 TypeScript의 표준 라이브러리에 Pick과 Record와 함께 포함되어 있습니다:
    
+
    Readonly<T>와 Partial<T>가 아주 유용하다는 것을 주목하세요, 이들은 Pick과 Record와 함께 TypeScript의 표준 라이브러리에 포함되어 있습니다.
    
 
    type Pick<T, K extends keyof T> = {
     [P in K]: T[P];
 }
-type Record<K extends string, T> = {
+type Record<K extends keyof any, T> = {
     [P in K]: T;
 }
 
    
-
    Readonly, Partial과 Pick은 동형(homomorphic)인 반면 Record는 그렇지 않습니다.
    Record가 동형(homomorphic)이 아닌 한가지 단서는 프로퍼티를 복사하는 데 입력 타입을 사용하지 않는다는 점입니다:
    
+
    Readonly, Partial 그리고 Pick은 동형이지만 Record는 아닙니다.
+Record가 동형이 아니라는 단서 중 하나는 프로퍼티를 복사하는 입력 타입을 받지 않는 것입니다:
    
 
    type ThreeStringProps = Record<'prop1' | 'prop2' | 'prop3', string>
 
    
-
    동형이 아닌 타입은 본질적으로 새로운 프로퍼티를 생성하기 때문에 어디에서나 프로퍼티 지정자를 복사할 수 없습니다.
    
-
    mapped types의 추론 (Inference from mapped types)
    
-
    이제는 타입의 프로퍼티를 래핑하는 방법을 알았으므로 다음으로 해야 할 일은 언래핑(푸는) 것입니다.
    다행히도 꽤 쉽습니다 :
    
+
    비-동형 타입은 본질적으로 새로운 프로퍼티를 만듭니다, 그래서 어디서든지 프로퍼티 지정자를 복사할 수 없습니다.
    
+
    매핑 타입의 추론 (Inference from mapped types)
    
+
    타입의 프로퍼티를 어떻게 래핑 하는지 알게 되었으니, 다음에 하고 싶은 것은 어떻게 언래핑(unwrap) 할지입니다.
+다행히, 꽤 쉽습니다:
    
 
    function unproxify<T>(t: Proxify<T>): T {
     let result = {} as T;
     for (const k in t) {
@@ -1339,7 +1564,221 @@ 
    mappe
 
 let originalProps = unproxify(proxyProps);
 
    
-
    이 언래핑 추론은 동형 매핑 타입에서만 작동합니다.
    매핑된 타입이 동형이 아닌 경우에는 언래핑 함수에 명시적 타입 매개 변수를 지정해야 합니다.
    
+
    이 언래핑 추론은 동형 매핑된 타입에만 동작합니다.
+만약 매핑 타입이 동형이 아니면 언래핑 함수에 명시적인 타입 매개변수를 주어야 할 것입니다.
    
+
    조건부 타입 (Conditional Types)
    
+
    TypeScript 2.8에서 비-균등 타입 매핑을 표현하는 기능을 추가하는 조건부 타입을 도입했습니다.
+조건부 타입은 타입 관계 검사로 표현된 조건에 따라 두 가지 가능한 타입 중 하나를 선택합니다:
    
+
    T extends U ? X : Y
+
    
+
    위의 타입은 T가 U에 할당될 수 있으면 타입은 X가 되고 그렇지 않다면 타입이 Y가 된다는 것을 뜻합니다.
    
+
    조건부 타입 T extends U ? X : Y는 X 나 Y로 결정되거나, 지연됩니다, 왜냐하면 조건이 하나 혹은 그 이상의 타입 변수에 의존하기 때문입니다.
+T나 U가 타입 변수를 포함할 때, X 또는 Y로 결정되거나 지연될지, 타입 시스템이 T가 항상 U에 할당할 수 있는지에 대해 충분한 정보를 가지고 있는지 여부로 결정됩니다.
    
+
    즉시 결정되는 일부 타입의 예제로, 다음 예제를 살펴보겠습니다:
    
+
    declare function f<T extends boolean>(x: T): T extends true ? string : number;
+
+// 타입은 'string | number'
+let x = f(Math.random() < 0.5)
+
    
+
    또 다른 예제는 중첩 조건부 타입을 사용하는 TypeName 타입 별칭입니다:
    
+
    type TypeName<T> =
+    T extends string ? "string" :
+    T extends number ? "number" :
+    T extends boolean ? "boolean" :
+    T extends undefined ? "undefined" :
+    T extends Function ? "function" :
+    "object";
+
+type T0 = TypeName<string>;  // "string"
+type T1 = TypeName<"a">;  // "string"
+type T2 = TypeName<true>;  // "boolean"
+type T3 = TypeName<() => void>;  // "function"
+type T4 = TypeName<string[]>;  // "object"
+
    
+
    하지만 조건부 타입이 지연되는 지점 - 분기를 선택하기보단 고정되는 - 의 예를 들면 다음과 같습니다:
    
+
    interface Foo {
+    propA: boolean;
+    propB: boolean;
+}
+
+declare function f<T>(x: T): T extends Foo ? string : number;
+
+function foo<U>(x: U) {
+    // 'U extends Foo ? string : number' 타입을 가지고 있습니다
+    let a = f(x);
+
+    // 이 할당은 허용됩니다!
+    let b: string | number = a;
+}
+
    
+
    위에서, 변수 a는 아직 분기를 선택하지 못한 조건부 타입을 가지고 있습니다.
+또 다른 코드가 foo의 호출을 그만두면, U를 다른 타입으로 대체할 것이고, TypeScript가 실제로 분기를 선택할 수 있는지 결정하기 위해 조건부 타입을 재-평가할 것입니다.
    
+
    그동안, 조건부 타입을 조건부의 각 분기가 대상에 할당 가능한 한 다른 대상 타입으로 할당할 수 있습니다.
+그래서 위 예제에서 조건부가 어떻게 평가되든지, string혹은 number로 알려져 있기 때문에, 조건이 U extends Foo ? string : numer를 string | number로 할당할 수 있었습니다.
    
+
    분산 조건부 타입 (Distributive conditional types)
    
+
    검사된 타입이 벗겨진 (naked) 타입 매개변수인 조건부 타입을 분산 조건부 타입이라고 합니다.
+분산 조건부 타입은 인스턴스화 중에 자동으로 유니언 타입으로 분산됩니다.
+예를 들어, T에 대한 타입 인수 A | B | C를 사용하여 T extends U ? X : Y를 인스턴스화하면 (A extends U ? X : Y) | (B extends U ? X : Y) | (C extends U ? X : Y)로 결정됩니다.
    
+
    예제
    
+
    type T10 = TypeName<string | (() => void)>;  // "string" | "function"
+type T12 = TypeName<string | string[] | undefined>;  // "string" | "object" | "undefined"
+type T11 = TypeName<string[] | number[]>;  // "object"
+
    
+
    분산 조건부 타입 T extends U ? X : Y의 인스턴스화에서,
+조건부 타입 내의 T에 대한 참조는 유니언 타입의 개별 성분으로 결정됩니다 (즉 T가 조건부 타입이 유니언 타입으로 분산된 후에 개별 성분을 참조합니다).
+게다가, X 안의 T에 대한 참조에는 추가적인 타입 매개변수 제약 조건 (constraint) U가 있습니다 (즉 T는 X 안에서 U에 할당 가능하다고 간주됩니다).
    
+
    예제
    
+
    type BoxedValue<T> = { value: T };
+type BoxedArray<T> = { array: T[] };
+type Boxed<T> = T extends any[] ? BoxedArray<T[number]> : BoxedValue<T>;
+
+type T20 = Boxed<string>;  // BoxedValue<string>;
+type T21 = Boxed<number[]>;  // BoxedArray<number>;
+type T22 = Boxed<string | number[]>;  // BoxedValue<string> | BoxedArray<number>;
+
    
+
    T가 실제 Boxed<T>의 분기 안에서 추가 제약조건 any[]을 가지고 있고 T[number]로 배열의 요소 타입을 참조할 수 있음을 유의하세요. 또한 지난 예제에서 조건부 타입이 어떻게 유니언 타입으로 분산되었는지 확인하세요.
    
+
    조건부 타입의 분산 프로퍼티는 유니언 타입을 필터링하는데 편하게 사용할 수 있습니다:
    
+
    type Diff<T, U> = T extends U ? never : T;  // U에 할당할 수 있는 타입을 T에서 제거
+type Filter<T, U> = T extends U ? T : never;  // U에 할당할 수 없는 타입을 T에서 제거
+
+type T30 = Diff<"a" | "b" | "c" | "d", "a" | "c" | "f">;  // "b" | "d"
+type T31 = Filter<"a" | "b" | "c" | "d", "a" | "c" | "f">;  // "a" | "c"
+type T32 = Diff<string | number | (() => void), Function>;  // string | number
+type T33 = Filter<string | number | (() => void), Function>;  // () => void
+
+type NonNullable<T> = Diff<T, null | undefined>;  // T에서 null과 undefined를 제거
+
+type T34 = NonNullable<string | number | undefined>;  // string | number
+type T35 = NonNullable<string | string[] | null | undefined>;  // string | string[]
+
+function f1<T>(x: T, y: NonNullable<T>) {
+    x = y;  // 성공
+    y = x;  // 오류
+}
+
+function f2<T extends string | undefined>(x: T, y: NonNullable<T>) {
+    x = y;  // 성공
+    y = x;  // 오류
+    let s1: string = x;  // 오류
+    let s2: string = y;  // 성공
+}
+
    
+
    조건부 타입은 특히 매핑 타입과 결합할 때 유용합니다.
    
+
    type FunctionPropertyNames<T> = { [K in keyof T]: T[K] extends Function ? K : never }[keyof T];
+type FunctionProperties<T> = Pick<T, FunctionPropertyNames<T>>;
+
+type NonFunctionPropertyNames<T> = { [K in keyof T]: T[K] extends Function ? never : K }[keyof T];
+type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;
+
+interface Part {
+    id: number;
+    name: string;
+    subparts: Part[];
+    updatePart(newName: string): void;
+}
+
+type T40 = FunctionPropertyNames<Part>;  // "updatePart"
+type T41 = NonFunctionPropertyNames<Part>;  // "id" | "name" | "subparts"
+type T42 = FunctionProperties<Part>;  // { updatePart(newName: string): void }
+type T43 = NonFunctionProperties<Part>;  // { id: number, name: string, subparts: Part[] }
+
    
+
    유니언과 교차 타입과 유사하게, 조건부 타입은 재귀적으로 자기 자신을 참조할 수 없습니다.
+예를 들어 다음의 예제는 오류입니다.
    
+
    예제
    
+
    type ElementType<T> = T extends any[] ? ElementType<T[number]> : T;  // 오류
+
    
+
    조건부 타입의 타입 추론 (Type inference in conditional types)
    
+
    조건부 타입의 extends 절 안에서, 이제 추론 될 타입 변수를 도입하는 infer 선언을 가지는 것이 가능합니다.
+이렇게 추론된 타입 변수는 조건부 타입의 실제 분기에서 참조될 수 있습니다.
+같은 타입 변수에 대한 여러 개의 infer 위치를 가질 수 있습니다.
    
+
    예를 들어, 다음은 함수 타입의 반환 타입을 추출합니다.
    
+
    type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any;
+
    
+
    조건부 타입은 순서대로 평가되는 일련의 패턴 일치를 형성하기 위해 중첩될 수 있습니다.
    
+
    type Unpacked<T> =
+    T extends (infer U)[] ? U :
+    T extends (...args: any[]) => infer U ? U :
+    T extends Promise<infer U> ? U :
+    T;
+
+type T0 = Unpacked<string>;  // string
+type T1 = Unpacked<string[]>;  // string
+type T2 = Unpacked<() => string>;  // string
+type T3 = Unpacked<Promise<string>>;  // string
+type T4 = Unpacked<Promise<string>[]>;  // Promise<string>
+type T5 = Unpacked<Unpacked<Promise<string>[]>>;  // string
+
    
+
    다음 예제는 어떻게 공변 (co-variant) 위치에서 같은 타입 변수에 대한 여러 후보가 유니언 타입을 추론하는지 보여줍니다:
    
+
    type Foo<T> = T extends { a: infer U, b: infer U } ? U : never;
+type T10 = Foo<{ a: string, b: string }>;  // string
+type T11 = Foo<{ a: string, b: number }>;  // string | number
+
    
+
    마찬가지로, 반-변(contra-variant) 위치에서 같은 타입 변수에 대한 여러 후보가 교차 타입을 추론합니다:
    
+
    type Bar<T> = T extends { a: (x: infer U) => void, b: (x: infer U) => void } ? U : never;
+type T20 = Bar<{ a: (x: string) => void, b: (x: string) => void }>;  // string
+type T21 = Bar<{ a: (x: string) => void, b: (x: number) => void }>;  // string & number
+
    
+
    여러 호출 시그니처가 있는 타입에서 추론할 때 (오버로딩된 함수의 타입과 같은), 추론은 마지막 시그니처에서 만들어집니다 (이는 아마도 가장 관대한 케이스 일 것입니다).
+인수 타입의 리스트를 기반으로 오버로드 해결을 수행할 수는 없습니다.
    
+
    declare function foo(x: string): number;
+declare function foo(x: number): string;
+declare function foo(x: string | number): string | number;
+type T30 = ReturnType<typeof foo>;  // string | number
+
    
+
    일반 타입 매개변수에 대한 제약조건 절에서 infer 선언을 사용할 수 없습니다.
    
+
    type ReturnType<T extends (...args: any[]) => infer R> = R;  // 오류, 지원되지 않습니다.
+
    
+
    하지만, 제약조건에서 타입 변수를 지우고 대신에 조건부 타입을 지정하면 거의 같은 효과를 얻을 수 있습니다:
    
+
    type AnyFunction = (...args: any[]) => any;
+type ReturnType<T extends AnyFunction> = T extends (...args: any[]) => infer R ? R : any;
+
    
+
    미리 정의된 조건부 타입 (Predefined conditional types)
    
+
    TypeScript 2.8에서 lib.d.ts에 미리 정의된 조건부 타입을 추가했습니다.
    
+
      
+
    • Exclude<T, U> -- U에 할당할 수 있는 타입은 T에서 제외.
      • 
+
    • Extract<T, U> -- U에 할당할 수 있는 타입을 T에서 추출
      • 
+
    • NonNullable<T> -- T에서 null과 undefined를 제외.
      • 
+
    • ReturnType<T> -- 함수 타입의 반환 타입을 얻기.
      • 
+
    • InstanceType<T> -- 생성자 함수 타입의 인스턴스 타입을 얻기.
      • 
+
    
+
    예제
    
+
    type T00 = Exclude<"a" | "b" | "c" | "d", "a" | "c" | "f">;  // "b" | "d"
+type T01 = Extract<"a" | "b" | "c" | "d", "a" | "c" | "f">;  // "a" | "c"
+
+type T02 = Exclude<string | number | (() => void), Function>;  // string | number
+type T03 = Extract<string | number | (() => void), Function>;  // () => void
+
+type T04 = NonNullable<string | number | undefined>;  // string | number
+type T05 = NonNullable<(() => string) | string[] | null | undefined>;  // (() => string) | string[]
+
+function f1(s: string) {
+    return { a: 1, b: s };
+}
+
+class C {
+    x = 0;
+    y = 0;
+}
+
+type T10 = ReturnType<() => string>;  // string
+type T11 = ReturnType<(s: string) => void>;  // void
+type T12 = ReturnType<(<T>() => T)>;  // {}
+type T13 = ReturnType<(<T extends U, U extends number[]>() => T)>;  // number[]
+type T14 = ReturnType<typeof f1>;  // { a: number, b: string }
+type T15 = ReturnType<any>;  // any
+type T16 = ReturnType<never>;  // never
+type T17 = ReturnType<string>;  // 오류
+type T18 = ReturnType<Function>;  // 오류
+
+type T20 = InstanceType<typeof C>;  // C
+type T21 = InstanceType<any>;  // any
+type T22 = InstanceType<never>;  // never
+type T23 = InstanceType<string>;  // 오류
+type T24 = InstanceType<Function>;  // 오류
+
    
+
    
+
    Note: Exclude 타입은 여기에서 제안된 Diff 타입의 적절한 구현입니다. Diff를 정의한 코드와의 충돌을 피하기 위해 Exclude를 사용했고, 또 이 이름이 타입의 의미를 더 잘 전달한다고 느꼈습니다.
    
+
    @@ -1383,7 +1822,7 @@

    No results matching " var gitbook = gitbook || []; gitbook.push(function() { - gitbook.page.hasChanged({"page":{"title":"고급 타입","level":"3.10","depth":1,"next":{"title":"심볼","level":"3.11","depth":1,"path":"pages/Symbols.md","ref":"pages/Symbols.md","articles":[]},"previous":{"title":"타입 호환성","level":"3.9","depth":1,"path":"pages/Type Compatibility.md","ref":"pages/Type Compatibility.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Advanced Types.md","mtime":"2019-06-14T05:32:52.232Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}}); + gitbook.page.hasChanged({"page":{"title":"고급 타입","level":"3.10","depth":1,"next":{"title":"심볼","level":"3.11","depth":1,"path":"pages/Symbols.md","ref":"pages/Symbols.md","articles":[]},"previous":{"title":"타입 호환성","level":"3.9","depth":1,"path":"pages/Type Compatibility.md","ref":"pages/Type Compatibility.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Advanced Types.md","mtime":"2020-04-22T15:29:36.171Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}}); }); diff --git a/pages/Basic Types.html b/pages/Basic Types.html index 142a4cec..16c026bf 100644 --- a/pages/Basic Types.html +++ b/pages/Basic Types.html @@ -481,6 +481,19 @@ + + +
  • + + + + + 유틸리티 타입 + + + + +
    • @@ -627,7 +640,20 @@ -
  • +
  • + + + + + 프로젝트 레퍼런스 + + + + + +
    • + +
  • @@ -640,7 +666,7 @@
    • -
  • +
  • @@ -653,7 +679,7 @@
    • -
  • +
  • @@ -668,6 +694,26 @@ + +
  • 릴리즈 노트
    • + + + +
  • + + + + + TypeScript 3.8 + + + + + +
    • + + +
  • @@ -711,160 +757,222 @@

    -

    소개 (Introduction)

    -

    프로그램을 유용하게 사용하려면 숫자, 문자열, 구조, 부울 값 등과 같은 몇 가지 간단한 데이터 단위로 작업할 수 있어야 합니다. TypeScript에서는 사용자가 JavaScript에서 기대하는 것과 같은 타입을 지원하며 이를 지원하기 위해 편리한 열거형을 포함합니다.

    -

    부울 (Boolean)

    -

    가장 기본적인 데이터 타입은 JavaScript와 TypeScript가 boolean 값을 호출하는 단순한 true / false 값입니다.

    +

    목차 (Table of Contents)

    +
      +
    1. 소개 (Introduction)
      2. +
    2. 불리언 (Boolean)
      3. +
    3. 숫자 (Number)
      4. +
    4. 문자열 (String)
      5. +
    5. 배열 (Array)
      6. +
    6. 튜플 (Tuple)
      7. +
    7. 열거 (Enum)
      8. +
    8. Any
      9. +
    9. Void
      10. +
    10. Null and Undefined
      11. +
    11. Never
      12. +
    12. 객체 (Object)
      13. +
    13. 타입 단언 (Type assertions)
      14. +
    14. 'let'에 관하여
      15. +
    +

    소개 (Introduction)

    +

    프로그램이 유용하려면 숫자, 문자열, 구조체, 불리언 값과 같은 간단한 데이터 단위가 필요합니다. +TypeScript는 JavaScript와 거의 동일한 데이터 타입을 지원하며, 열거 타입을 사용하여 더 편리하게 사용할 수 있습니다.

    +

    불리언 (Boolean)

    +

    가장 기본적인 데이터 타입은 JavaScript, TypeScript에서 boolean 값이라고 일컫는 참/거짓(true/false) 값입니다.

    let isDone: boolean = false;
    -

    숫자형 (Number)

    -

    JavaScript와 마찬가지로 TypeScript의 모든 숫자는 부동 소수 점 값입니다.
    이 부동 소수 점 숫자는 number 타입을 받습니다.
    TypeScript는 10진수 및 16진수와 함께 ECMAScript2015에 도입된 2진수 및 8진수 문자를 지원합니다.

    +

    숫자 (Number)

    +

    JavaScript처럼, TypeScript의 모든 숫자는 부동 소수 값입니다. +부동 소수에는 number라는 타입이 붙혀집니다. +TypeScript는 16진수, 10진수 리터럴에 더불어, ECMAScript 2015에 소개된 2진수, 8진수 리터럴도 지원합니다.

    let decimal: number = 6;
 let hex: number = 0xf00d;
 let binary: number = 0b1010;
 let octal: number = 0o744;

    문자열 (String)

    -

    웹 페이지와 서버를 위한 JavaScript 프로그램을 만드는 또 다른 기본적인 부분은 텍스트 데이터를 사용하는 것입니다.
    다른 언어와 같이 이러한 텍스트의 데이터 타입을 참조하기 위해 string 타입을 사용합니다.
    JavaScript와 마찬가지로 TypeScript 또한 문자열 데이터를 감싸기 위해 큰 따옴표(") 또는 작은 따옴표(')를 사용합니다.

    +

    웹 페이지, 서버 같은 프로그램을 JavaScript로 만들 때 기본적으로 텍스트 데이터를 다루는 작업이 필요합니다. +다른 언어들처럼, TypeScript에서는 텍스트 테이터 타입을 string으로 표현합니다. +JavaScript처럼 TypeScript도 큰따옴표 (")나 작은따옴표 (')를 문자열 데이터를 감싸는데 사용합니다.

    let color: string = "blue";
 color = 'red';
    -

    여러 줄에 걸쳐 표현식을 포함할 수 있는 템플릿 문자열 을 사용할 수도 있습니다.
    이 문자열은 백틱 / 백 쿼트 (` ) 문자로 감싸져 있으며 포함된 표현식은 ${ 표현식 } 형식입니다.

    +

    또한 템플릿 문자열 을 사용하면 여러 줄에 걸쳐 문자열을 작성할 수 있으며, 표현식을 포함시킬 수도 있습니다. +이 문자열은 백틱/백쿼트 (` ) 문자로 감싸지며, ${ expr }과 같은 형태로 표현식을 포함시킬 수 있습니다.

    let fullName: string = `Bob Bobbington`;
 let age: number = 37;
 let sentence: string = `Hello, my name is ${ fullName }.
-
 I'll be ${ age + 1 } years old next month.`;
    -

    이것은 위와 같이 선언한 문장과 같습니다.

    +

    위는 아래 sentence선언과 동일합니다:

    let sentence: string = "Hello, my name is " + fullName + ".\n\n" +
     "I'll be " + (age + 1) + " years old next month.";

    배열 (Array)

    -

    TypeScript는 JavaScript와 같이 값의 배열을 사용할 수 있도록 합니다.
    배열의 타입은 두 가지 방법 중 하나로 작성 될 수 있습니다.

    -

    첫번째, 요소 타입의 배열을 나타내기 위해 [] 다음에 오는 요소의 타입을 사용합니다.

    +

    TypeScript는 JavaScript처럼 값들을 배열로 다룰 수 있게 해줍니다. +배열 타입은 두 가지 방법으로 쓸 수 있습니다. +첫 번째 방법은, 배열 요소들을 나타내는 타입 뒤에 []를 쓰는 것입니다:

    let list: number[] = [1, 2, 3];
    -

    두 번째 방법으로는 제네릭 배열 타입을 사용합니다. Array<요소의 타입>:

    +

    두 번째 방법은 제네릭 베열 타입을 쓰는 것입니다. Array<elemType>:

    let list: Array<number> = [1, 2, 3];

    튜플 (Tuple)

    -

    튜플 타입은 고정된 개수의 요소 타입을 알고 있지만 반드시 같을 필요는 없는 배열을 표현할 수 있도록 합니다.
    예를 들어, 다음과 같은 string과 number의 쌍으로 값을 나타낼 수 있습니다 :

    -
    // 튜플 타입 선언
+
    튜플 타입을 사용하면, 요소의 타입과 개수가 고정된 배열을 표현할 수 있습니다. 단 요소들의 타입이 모두 같을 필요는 없습니다. 예를 들어, number, string 이 쌍으로 있는 값을 나타내고 싶을 수 있습니다:
    
+
    // 튜플 타입으로 선언
 let x: [string, number];
 // 초기화
-x = ["hello", 10]; // 좋아요
-// 부정확한 초기화
+x = ["hello", 10]; // 성공
+// 잘못된 초기화
 x = [10, "hello"]; // 오류
 
    
-
    알려진 인덱스을 사용하여 요소에 접근하는 경우에 올바른 타입이 검색됩니다.
    
-
    console.log(x[0].substr(1)); // 좋아요
-console.log(x[1].substr(1)); // 오류, 'number'은 'substr'을 가지고 있지 않습니다.
+
    정해진 인덱스에 위치한 요소에 접근하면 해당 타입이 나타납니다.
    
+
    console.log(x[0].substring(1)); // 성공
+console.log(x[1].substring(1)); // 오류, 'number'에는 'substring' 이 없습니다.
 
    
-
    알려진 인덱스 집합 외부의 요소에 접근할 때는 다음과 같이 Union 타입이 사용됩니다:
    
-
    x[3] = "world"; // 좋아요, 'string'은 'string | number'에 할당될 수 있습니다.
-
-console.log(x[5].toString()); // 좋아요, 'string' 및 'number'에 모두 'toString'이 있습니다.
+
    정해진 인덱스 외에 다른 인덱스에 있는 요소에 접근하면, 오류가 발생하며 실패합니다.
    
+
    x[3] = "world"; // 오류, '[string, number]' 타입에는 프로퍼티 '3'이 없습니다.
 
-x[6] = true; // 오류, 'boolean'은 'string | number' 타입이 아닙니다.
+console.log(x[5].toString()); // '[string, number]' 타입에는 프로퍼티 '5'가 없습니다.
 
    
-
    유니온 타입은 다음 장에서 다루게 될 고급 주제입니다.
    
 
    열거 (Enum)
    
-
    JavaScript의 표준 데이터 타입 집합에 추가할 수 있는 유용하고 부가적인 추가 자료는 enum 입니다.
    C#와 같은 언어에서처럼 enum은 numeric 값 집합에 더 친숙한 이름을 부여하는 방법이다.
    
+
    JavaScript의 표준 자료형 집합과 사용하면 도움이 될만한 데이터 형은 enum입니다.
+C# 같은 언어처럼, enum은 값의 집합에 더 나은 이름을 붙여줄 수 있습니다.
    
 
    enum Color {Red, Green, Blue}
 let c: Color = Color.Green;
 
    
-
    기본적으로 enums는 0부터 시작하는 자신의 멤버 번호를 매기기를 시작합니다.
    멤버 중 하나의 값을 수동으로 설정하여 이를 변경할 수 있습니다.
    예를 들어 이전 예제를 0 대신 1로 시작할 수 있습니다:
    
+
    기본적으로, enum은 0부터 시작하여 멤버들의 번호를 매깁니다.
+멤버 중 하나의 값을 수동으로 설정하여 번호를 바꿀 수 있습니다.
+예를 들어, 위 예제를 0대신 1부터 시작해 번호를 매기도록 바꿀 수 있습니다.
    
 
    enum Color {Red = 1, Green, Blue}
 let c: Color = Color.Green;
 
    
-
    또는 열거 형의 모든 값을 수동으로 설정합니다:
    
+
    또는, 모든 값을 수동으로 설정할 수 있습니다:
    
 
    enum Color {Red = 1, Green = 2, Blue = 4}
 let c: Color = Color.Green;
 
    
-
    enum의 편리한 기능은 숫자 값에서 enum의 해당 값 이름으로 이동할 수 있다는 것입니다.
    예를 들어, 값 2를 가지고 있지만 위의 Color enum에서 매핑된 값이 무엇인지 확실하지 않은 경우에 그에 상응하는 이름을 찾을 수 있습니다:
    
+
    enum의 유용한 기능 중 하나는 매겨진 값을 사용해 enum 멤버의 이름을 알아낼 수 있다는 것입니다.
+예를 들어, 위의 예제에서 2라는 값이 위의 어떤 Color enum 멤버와 매칭되는지 알 수 없을 때, 이에 일치하는 이름을 알아낼 수 있습니다:
    
 
    enum Color {Red = 1, Green, Blue}
 let colorName: string = Color[2];
 
-alert(colorName); // 위의 값이 2 이므로 'Green'을 표시합니다.
+console.log(colorName); // 값이 2인 'Green'이 출력됩니다.
 
    
 
    Any
    
-
    어플리케이션을 작성할 때 알지 못하는 변수의 타입을 설명해야 할 수도 있습니다.
    이러한 값은 사용자 또는 써드-파티 라이브러리와 같은 동적 컨텐츠에서 비롯될 수 있습니다.
    이러한 경우에는, 타입 검사를 선택하지 않고 그 값이 컴파일-타임 검사를 통과하도록 하고 싶습니다.
    이를 위해 다음과 같은 any 타입으로 지정합니다.
    
+
    애플리케이션을 만들 때, 알지 못하는 타입을 표현해야 할 수도 있습니다.
+이 값들은 동적인 콘텐츠에서 올 수도 있습니다. 예) 사용자로부터 받은 데이터. 혹은 3rd party library.
+이 경우 타입 검사를 하지 않고, 그 값들이 컴파일 시간에 검사를 통과하길 원합니다.
+이를 위해, any 타입을 사용할 수 있습니다:
    
 
    let notSure: any = 4;
-notSure = "문자열일수도 있다";
-notSure = false; // 좋아요, 확실한 boolean
+notSure = "maybe a string instead";
+notSure = false; // 성공, 분명히 부울입니다.
 
    
-
    any 타입은 기존 JavaScript로 작업할 수 있는 강력한 방법으로 컴파일 과정에서 타입 검사를 점진적으로 실행 (opt-in) 및 중지(opt-out) 할 수 있습니다.
    
-
    다른 언어와 마찬가지로 객체도 비슷한 역할을 할 것으로 예상할 수 있습니다.
    그러나 객체 타입의 변수를 사용하면 해당 객체에는 값만 할당할 수 있습니다 - 실제로 존재하는 것도 임의의 메서드를 호출할 수는 없습니다:
    
+
    any 타입은 기존에 JavaScript로 작업할 수 있는 강력한 방법으로, 컴파일 중에 점진적으로 타입 검사를 하거나 하지 않을 수 있습니다.
+혹 다른 언어에서 그렇듯, Object가 비슷한 역할을 할 수 있을 것 같다고 생각할 수도 있습니다.
+그런데, Object로 선언된 변수들은 오직 어떤 값이든 그 변수에 할당할 수 있게 해주지만 실제로 메서드가 존재하더라도, 임의로 호출할 수는 없습니다:
    
 
    let notSure: any = 4;
-notSure.ifItExists(); // 좋아요, 런타임에 ifItExists가 존재할 수 있습니다.
-notSure.toFixed(); // 좋아요, toFixed는 존재합니다. (그러나 컴파일러는 체크하지 않습니다)
+notSure.ifItExists(); // 성공, ifItExists 는 런타임엔 존재할 것입니다.
+notSure.toFixed(); // 성공, toFixed는 존재합니다. (하지만 컴파일러는 검사하지 않음)
 
 let prettySure: Object = 4;
-prettySure.toFixed(); // 오류: 'Object' 타입에 'toFixed' 프로퍼티는 존재하지 않습니다.
+prettySure.toFixed(); // 오류: 프로퍼티 'toFixed'는 'Object'에 존재하지 않습니다.
 
    
-
    any 타입은 일부를 알고 있는 경우에도 유용하지만 모두 그렇지는 않습니다.
    예를 들어 배열이 있지만 배열에는 다른 타입이 혼재되어 있습니다:
    
+
    
+
    Note: Do's and Don'ts에 설명 했듯이 Object를 no-primitive object 대신에 사용하지 마세요.
    
+
    
+
    또한, any 타입은 타입의 일부만 알고 전체는 알지 못할 때 유용합니다.
+예를 들어, 여러 다른 타입이 섞인 배열을 다룰 수 있습니다.
    
 
    let list: any[] = [1, true, "free"];
 
 list[1] = 100;
 
    
 
    Void
    
-
    void는 any의 정반대이지만 조금 비슷합니다: 어떠한 타입의 부재도 전혀 없습니다.
    일반적으로 반환 값을 반환하지 않는 함수의 반환 타입으로 볼 수 있습니다:
    
+
    void는 어떤 타입도 존재할 수 없음을 나타내기 때문에, any의 반대 타입 같습니다.
+void는 보통 함수에서 반환 값이 없을 때 반환 타입을 표현하기 위해 쓰이는 것을 볼 수 있습니다:
    
 
    function warnUser(): void {
-    alert("This is my warning message");
+    console.log("This is my warning message");
 }
 
    
-
    void 타입의 변수 선언은 undefined 또는 null 만 할당할 수 있으므로 유용하지 않습니다:
    
+
    void를 타입 변수를 선언하는 것은 유용하지 않은데, 왜냐하면 그 변수에는 null(--strictNullChecks을 사용하지 않을 때만 해당, 자세한 건 다음 섹션을 참고)또는 undefined 만 할당할 수 있기 때문입니다:
    
 
    let unusable: void = undefined;
+unusable = null; // 성공  `--strictNullChecks` 을 사용하지 않을때만
 
    
-
    Null 과 Undefined
    
-
    TypeScript에서 undefined와 null은 실제로 각기 undefined와 null이라는 자체적인 타입을 가집니다.
    void와 마찬가지로 그것들은 매우(극단적으로) 유용하지 않습니다 :
    
-
    // 그 외에도 이러한 변수에 할당할 수 있습니다!
+
    Null and Undefined
    
+
    TypeScript는 undefined 과 null 둘 다 각각 자신의 타입 이름으로 undefined , null로 사용합니다.
+void처럼 그 자체로 유용한 경우는 거의 없습니다:
    
+
    // 이 밖에 이 변수들에 할당할 수 있는 값이 없습니다!
 let u: undefined = undefined;
 let n: null = null;
 
    
-
    기본적으로 null과 undefined는 다른 모든 타입의 서브 타입입니다.
    즉 null과 undefined를 number와 같은 것으로 할당 할 수 있습니다.
    
-
    그러나 --strictNullChecks 플래그를 사용할 때 null과 undefined는 void와 그 각각의 타입에만 할당할 수 있습니다.
    이렇게 하면 많은 일반적인 오류를 피할 수 있습니다.
    string 또는 null 또는 undefined 중 하나를 전달하고자 하는 경우 string | null | undefined (union 타입)을 사용할 수 있습니다.
    다시 한 번 말하자면 이후에 더 많은 Union 타입에 관한 내용이 있습니다.
    
+
    기본적으로 null 과 undefined는 다른 모든 타입의 하위 타입니다.
+이건, null과 undefined를 number 같은 타입에 할당할 수 있다는 것을 의미합니다.
    
+
    하지만, --strictNullChecks를 사용하면, null과  undefined는 오직 any와 각자 자신들 타입에만 할당 가능합니다. (예외적으로 undefined는 void에 할당 가능합니다)
+이건 많은 일반적인 에러를 방지하는 데 도움을 줍니다.
+이 경우, string 또는 null 또는 undefined를 허용하고 싶은 경우 유니언 타입인 string | null | undefined를 사용할 수 있습니다.
    
+
    유니언 타입은 상급 주제로, 이후 챕터에서 다룹니다.
    
 
    
-
    메모: 가능한 한 --strictNullChecks 검사를 사용하도록 권장하지만 본 핸드북의 목적상 이 기능이 꺼져 있다고 가정하겠습니다.
    
+
    As a note: 가능한 경우 --structNullChecks를 사용할 것을 권장합니다. 하지만 핸드북의 목적에 따라, 사용하지 않는다고 가정합니다.
    
 
    
 
    Never
    
-
    never 타입은 절대로 발생하지 않는 값의 타입을 나타냅니다.
    예를 들어 never는 함수 표현식의 반환 타입이거나 항상 예외를 던지는 화살표 함수 표현식이거나 절대 반환하지 않는 표현식입니다.
    변수는 또한 never 일 때 타입 가드에 의해 좁혀지더라도 결코 사실일 수 없으며 타입을 획득하지 못합니다.
    
-
    never 타입은 모든 타입의 서브 타입이며 모든 타입에 할당할 수 있습니다.
    어떤 타입도 never의 서브 타입이거나 할당 가능한 타입은 아닙니다 (never 자체를 제외하고).
    any 조차도 never에 할당할 수 없습니다.
    
-
    never를 반환하는 함수의 몇 가지 예는 다음과 같습니다 :
    
-
    // 반환되는 함수에는 연결할 수 없는 end-point가 있어서는 안 됩니다.
+
    never 타입은 절대 발생할 수 없는 타입을 나타냅니다.
+예를 들어, never는 함수 표현식이나 화살표 함수 표현식에서 항상 오류를 발생시키거나 절대 반환하지 않는 반환 타입으로 쓰입니다.
+변수 또한 타입 가드에 의해 아무 타입도 얻지 못하게 좁혀지면 never 타입을 얻게 될 수 있습니다.
    
+
    never타입은 모든 타입에 할당 가능한 하위 타입입니다. 하지만 어떤 타입도 never에 할당할 수 있거나, 하위 타입이 아닙니다.(never 자신은 제외)
+심지어 any 도 never에 할당할 수 없습니다.
    
+
    never를 반환하는 몇 가지 예제입니다:
    
+
    // never를 반환하는 함수는 함수의 마지막에 도달할 수 없다.
 function error(message: string): never {
     throw new Error(message);
 }
 
-// 추론되는 반환 타입은 절대로 없습니다.
+// 반환 타입이 never로 추론된다.
 function fail() {
     return error("Something failed");
 }
 
-// 반환되는 함수에는 연결할 수 없는 end-point가 있어서는 안 됩니다.
+// never를 반환하는 함수는 함수의 마지막에 도달할 수 없다.
 function infiniteLoop(): never {
     while (true) {
     }
 }
 
    
+
    객체 (Object)
    
+
    object는 원시 타입이 아닌 타입을 나타냅니다. 예를 들어, number, string, boolean, bigint, symbol, null, 또는 undefined 가 아닌 나머지를 의미합니다.
    
+
    object 타입을 쓰면, Object.create 같은 API 가 더 잘 나타납니다. 예를 들어:
    
+
    declare function create(o: object | null): void;
+
+create({ prop: 0 }); // 성공
+create(null); // 성공
+
+create(42); // 오류
+create("string"); // 오류
+create(false); // 오류
+create(undefined); // 오류
+
    
 
    타입 단언 (Type assertions)
    
-
    때로는 TypeScript보다 더 많은 값을 알아야 하는 상황에 놓일 수도 있습니다.
    일반적으로 이 문제는 일부 엔티티의 타입이 현재 타입보다 더 구체적일 수 있다는 것을 알고 있을 때 발생합니다.
    
-
    Type assertions 은 컴파일러에게 "나를 믿어, 내가 하고 있는 일을 안다"라고 말하는 방법입니다.
    type assertion은 다른 언어의 형 변환(타입캐스팅)과 비슷하지만 특별한 검사나 데이터를 재구성하지는 않습니다.
    런타임에 영향을 미치지 않으며 컴파일러에서만 사용됩니다.
    TypeScript는 개발자가 필요한 특별한 검사를 수행했다고 가정합니다.
    
-
    Type assertions은 두 가지 형태를 가집니다.
    하나는 "angle-bracket" (꺾쇠괄호) 구문입니다:
    
+
    가끔, TypeScript보다 개발자가 값에 대해 더 잘 알고 일을 때가 있습니다.
+대개, 이런 경우는 어떤 엔티티의 실제 타입이 현재 타입보다 더 구체적일 때 발생합니다.
    
+
    타입 단언(Type assertions) 은 컴파일러에게 "날 믿어, 난 내가 뭘 하고 있는지 알아"라고 말해주는 방법입니다.
+타입 단언은 다른 언어의 타입 변환(형 변환)과 유사하지만, 다른 특별한 검사를 하거나 데이터를 재구성하지는 않습니다.
+이는 런타임에 영향을 미치지 않으며, 온전히 컴파일러만 이를 사용합니다.
+타입 스크립트는 개발자가 필요한 어떤 특정 검사를 수행했다고 인지합니다.
    
+
    타입 단언에는 두 가지 형태가 있습니다.
+하나는, "angle-bracket" 문법입니다:
    
 
    let someValue: any = "this is a string";
 
 let strLength: number = (<string>someValue).length;
 
    
-
    그리고 다른 하나는 구문은 as 입니다 :
    
+
    다른 하나는 as-문법 입니다.
    
 
    let someValue: any = "this is a string";
 
 let strLength: number = (someValue as string).length;
 
    
-
    두 샘플은 동일합니다.
    다른 하나를 사용하는 것은 주로 선호도에 따른 선택입니다.
    그러나 TypeScript를 JSX와 함께 사용할 때는 as 스타일의 단언만 허용됩니다.
    
-
    let에 대한 메모
    
-
    지금까지 우리가 알고 있는 JavaScript의 var 키워드 대신 let 키워드를 사용했음을 알 수 있습니다.
    
-
    let 키워드는 실제로 TypeScript에서 사용할 수 있는 더욱 새로운 JavaScript 구문입니다.
    나중에 더 자세히 논의하겠지만 JavaScript가 가지고 있는 많은 흔한 문제들은 let의 사용으로 해결할 수 있기 때문에 가능할 때마다 var 대신 let을 사용하는 것이 좋습니다.
    
+
    위 두 예제는 동일합니다.
+어떤 것을 사용할지는 주로 선호에 따른 선택입니다. 하지만 TypeScript를 JSX와 함께 사용할 때는, as-스타일의 단언만 허용됩니다.
    
+
    let에 관하여
    
+
    지금까지 더 익숙할 수도 있는 JavaScript의 var 키워드 대신 let 키워드를 이용했다는 걸 알 수 있습니다.
+let 키워드는 JavaScript ES2015에서 소개되었고, var보다 안전하다는 이유로, 현재 표준으로 여겨지고 있습니다.
+나중에 더 자세히 살펴보겠지만, 대부분의 JavaScript의 문제들이 let을 사용해서 해결되며, 때문에 가능한 경우 최대한 var대신 let을 사용하셔야 합니다.
    @@ -908,7 +1016,7 @@

    No results matching " var gitbook = gitbook || []; gitbook.push(function() { - gitbook.page.hasChanged({"page":{"title":"기본 타입","level":"3.1","depth":1,"next":{"title":"변수 선언","level":"3.2","depth":1,"path":"pages/Variable Declarations.md","ref":"pages/Variable Declarations.md","articles":[]},"previous":{"title":"리액트 & 웹팩","level":"2.5","depth":1,"path":"pages/tutorials/React & Webpack.md","ref":"pages/tutorials/React & Webpack.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Basic Types.md","mtime":"2019-06-14T05:32:52.233Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}}); + gitbook.page.hasChanged({"page":{"title":"기본 타입","level":"3.1","depth":1,"next":{"title":"변수 선언","level":"3.2","depth":1,"path":"pages/Variable Declarations.md","ref":"pages/Variable Declarations.md","articles":[]},"previous":{"title":"리액트 & 웹팩","level":"2.5","depth":1,"path":"pages/tutorials/React & Webpack.md","ref":"pages/tutorials/React & Webpack.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Basic Types.md","mtime":"2020-04-22T15:29:36.171Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}}); }); diff --git a/pages/Classes.html b/pages/Classes.html index 027006df..3040d02d 100644 --- a/pages/Classes.html +++ b/pages/Classes.html @@ -481,6 +481,19 @@ + + +
  • + + + + + 유틸리티 타입 + + + + +
    • @@ -627,7 +640,20 @@ -
  • +
  • + + + + + 프로젝트 레퍼런스 + + + + + +
    • + +
  • @@ -640,7 +666,7 @@
    • -
  • +
  • @@ -653,7 +679,7 @@
    • -
  • +
  • @@ -668,6 +694,26 @@ + +
  • 릴리즈 노트
    • + + + +
  • + + + + + TypeScript 3.8 + + + + + +
    • + + +
  • @@ -712,9 +758,11 @@

    소개 (Introduction)

    -

    전통적인 JavaScript는 재사용 가능한 컴포넌트를 만들기 위해 함수와 프로토 타입 기반의 상속을 사용하지만 클래스가 함수를 상속하고 객체가 이러한 클래스에서 구축되는 객체 지향 접근 방식에 익숙하지 않은 개발자들에게는 다소 어색함을 느낄 수 있습니다.
    ECMAScript6로도 알려진 ECMAScript 2015년을 시작으로 JavaScript 개발자는 이 객체 지향 클래스 기반 접근 방식을 사용하여 응용 프로그램을 구축 할 수 있습니다.
    TypeScript에서는 개발자가 이 기술을 사용하고 다음 JavaScript 버전을 기다리지 않고도 모든 메이저 브라우저와 플랫폼에서 작동하는 JavaScript로 컴파일 할 수 있습니다.

    +

    기존 JavaScript는 재사용할 수 있는 컴포넌트를 만들기 위해 함수와 프로토타입-기반 상속을 사용했지만, 객체 지향 접근 방식에 익숙한 프로그래머의 입장에서는 클래스가 함수를 상속받고 이런 클래스에서 객체가 만들어지는 것에 다소 어색함을 느낄 수 있습니다. +ECMAScript 6로도 알려진 ECMAScript 2015를 시작으로 JavaScript 프로그래머들은 이런 객체-지향적 클래스-기반의 접근 방식을 사용해서 애플리케이션을 만들 수 있습니다. +TypeScript에서는 다음 버전의 JavaScript를 기다릴 필요 없이 개발자들이 이러한 기법들을 사용할 수 있게 해주며, 기존의JavaScript로 컴파일하여 주요 브라우저와 플랫폼에서 동작하게 합니다.

    클래스 (Classes)

    -

    간단한 클래스 기반 예제를 살펴보겠습니다:

    +

    간단한 클래스-기반 예제를 살펴보겠습니다:

    class Greeter {
     greeting: string;
     constructor(message: string) {
@@ -727,13 +775,15 @@ 
    클래스 (Classes)
    let greeter = new Greeter("world");
    -

    이전에 C# 또는 Java를 사용한 적이 있는 경우 구문이 익숙하게 보여야 합니다.
    새로운 클래스인 Greeter을 선언합니다. -이 클래스에는 3개의 멤버가 있습니다: greeting 프로퍼티와 생성자 그리고 greet 메서드가 있습니다.

    -

    클래스의 멤버 중 하나를 참조할 때 클래스에서 this를 앞에 접두어로 붙입니다. -이것은 멤버에 접근하는 것을 뜻합니다.

    -

    마지막 줄에서는 new를 사용하여 Greeter 클래스의 인스턴스를 만듭니다.
    이것은 이전에 정의한 생성자를 호출하여 Greeter 형태의 새 객체를 만들고 생성자를 실행하여 이를 초기화합니다.

    +

    C# 이나 Java를 사용해봤다면, 익숙한 구문일 것입니다. +새로운 클래스 Greeter를 선언했습니다. 이 클래스는 3개의 멤버를 가지고 있습니다: greeting 프로퍼티, 생성자 그리고 greet 메서드 입니다.

    +

    클래스 안에서 클래스의 멤버를 참조할 때 this.를 앞에 덧붙이는 것을 알 수 있습니다. +이것은 멤버에 접근하는 것을 의미합니다.

    +

    마지막 줄에서, new를 사용하여 Greeter클래스의 인스턴스를 생성합니다. +이 코드는 이전에 정의한 생성자를 호출하여 Greeter 형태의 새로운 객체를 만들고, 생성자를 실행해 초기화합니다.

    상속 (Inheritance)

    -

    TypeScript에서는 일반적인 객체 지향 패턴을 사용할 수 있습니다.
    클래스 기반 프로그래밍에서 가장 기본적인 패턴 중 하나는 상속을 사용하여 기존 클래스를 확장하여 새로운 클래스를 생성할 수 있다는 것입니다.

    +

    TypeScript에서는, 일반적인 객체-지향 패턴을 사용할 수 있습니다. +클래스-기반 프로그래밍의 가장 기본적인 패턴 중 하나는 상속을 이용하여 이미 존재하는 클래스를 확장해 새로운 클래스를 만들 수 있다는 것입니다.

    예제를 살펴보겠습니다:

    class Animal {
     move(distanceInMeters: number = 0) {
@@ -752,9 +802,11 @@ 
    상속 (Inheritance)
    
 dog.move(10);
 dog.bark();
    -

    이 예제는 가장 기본적인 상속 기능을 보여줍니다: 클래스는 기본 클래스에서 속성과 메서드를 상속받습니다.
    여기서 Dog는 extends 키워드를 사용하여 Animal 기본 클래스에서 유래된 파생 클래스입니다.
    파생 클래스는 종종 하위 클래스(subclasses) 라고 하며 기본 클래스는 슈퍼 클래스(superclasses) 라고도 합니다.

    -

    Dog는 Animal로부터 기능을 확장시키기 때문에 bark()와 move() 둘 다 할 수 있는 Dog의 인스턴스를 만들 수 있었습니다.

    -

    이제 좀 더 복잡한 예제를 살펴보겠습니다.

    +

    상속 기능을 보여주는 가장 기본적인 예제입니다: 클래스는 기초 클래스로부터 프로퍼티와 메서드를 상속받습니다. +여기서, Dog은 extends 키워드를 사용하여 Animal이라는 기초 클래스로부터 파생된 파생 클래스입니다. +파생된 클래스는 하위클래스(subclasses), 기초 클래스는 상위클래스(superclasses) 라고 불리기도 합니다.

    +

    Dog는 Animal의 기능을 확장하기 때문에, bark()와 move()를 모두 가진 Dog 인스턴스를 생성할 수 있습니다.

    +

    조금 더 복잡한 예제를 살펴보겠습니다.

    class Animal {
     name: string;
     constructor(theName: string) { this.name = theName; }
@@ -785,22 +837,26 @@ 
    상속 (Inheritance)
    
 sam.move();
 tom.move(34);
    -

    이 예제는 앞서 언급하지 않은 몇 가지 다른 기능을 다룹니다.
    이번에도 Animal의 새로운 하위 클래스인 Horse과 Snake을 만드는 extends 키워드가 등장합니다.

    -

    이전 예제와의 한 가지 다른 점은 생성자 함수를 포함하는 각 파생 클래스가 기본 클래스의 생성자를 실행할 super()를 호출해야한다는 것입니다.
    게다가 생성자 내에서 this에 있는 프로퍼티에 접근하기 전에 항상 super()를 호출해야 합니다.
    이것은 TypeScript가 적용할 중요한 규칙입니다.

    -

    또한 이 예제에서는 기본 클래스의 메서드를 하위 클래스에 특화된 메서드를 오버라이드 하는 방법도 보여 줍니다.

    -

    여기에서 Snake와 Horse는 Animal의 move를 오버라이드하고 각 클래스에 고유한 기능을 부여하는 move 메서드를 만듭니다.

    -

    tom은 Animal로 선언되었지만 Horse의 값을 가지므로 tom.move(34)를 호출하면 Horse의 오버라이딩 메서드가 호출됩니다:

    -
    Slithering...
-Sammy the Python moved 5m.
-Galloping...
-Tommy the Palomino moved 34m.
+
    이 예제는 앞에서 언급하지 않은 몇 가지 기능을 다룹니다.
+이번에도 extends 키워드를 사용하여 Animal의 하위클래스를 생성합니다: Horse와 Snake.
    
+
    이전 예제와 한 가지 다른 부분은 파생된 클래스의 생성자 함수는 기초 클래스의 생성자를 실행할 super()를 호출해야 한다는 점입니다.
+더욱이 생성자 내에서 this에 있는 프로퍼티에 접근하기 전에 super()를 먼저 호출해야 합니다.
+이 부분은 TypeScript에서 중요한 규칙입니다.
    
+
    또한 이 예제는 기초 클래스의 메서드를 하위클래스에 특화된 메서드로 오버라이드하는 방법을 보여줍니다.
+여기서 Snake와 Horse는 Animal의 move를 오버라이드해서 각각 클래스의 특성에 맞게 기능을 가진 move를 생성합니다.
+tom은 Animal로 선언되었지만 Horse의 값을 가지므로 tom.move(34)는 Horse의 오버라이딩 메서드를 호출합니다.
    
+
    Slithering...
+Sammy the Python moved 5m.
+Galloping...
+Tommy the Palomino moved 34m.
 
    
-
    Public, private, 그리고 protected 지정자 (Public, private, and protected modifiers)
    
-
    기본적인 Public (Public by default)
    
-
    예를 들어 프로그램을 통해 선언된 멤버들에 자유롭게 접근할 수 있었습니다.
    
-
    다른 언어의 클래스에 익숙하다면 위의 예제에서 public을 사용하지 않아도 된다는 사실을 알았을 것입니다.
    예를 들어 C#의 경우 각 멤버를 public으로 표시하도록 명시해야합니다.
    
-
    TypeScript에서는 기본적으로 각 멤버가 public입니다.
    
-
    그럼에도 불구하고 public를 멤버를 명시적으로 표시할 수 있습니다.
    이전 섹션의 Animal 클래스를 다음과 같이 작성할 수 있었습니다:
    
+
    Public, private 그리고 protected 지정자 (Public, private, and protected modifiers)
    
+
    기본적으로 공개 (Public by default)
    
+
    우리 예제에서는, 프로그램 내에서 선언된 멤버들에 자유롭게 접근할 수 있습니다.
+다른 언어의 클래스가 익숙하다면, 위 예제에서 public을 사용하지 않아도 된다는 점을 알 수 있습니다. 예를 들어, C#에서는 노출 시킬 각 멤버에 public을 붙여야 합니다.
+TypeScript에서는 기본적으로 각 멤버는 public입니다.
    
+
    명시적으로 멤버를 public으로 표시할 수도 있습니다.
+이전 섹션의 Animal 클래스를 다음과 같은 방식으로 작성할 수 있습니다:
    
 
    class Animal {
     public name: string;
     public constructor(theName: string) { this.name = theName; }
@@ -809,19 +865,32 @@ 
    기¼
     }
 }
 
    
-
    private 이해하기 (Understanding private)
    
-
    멤버가 private으로 표시되면 그 멤버를 포함하는 클래스의 외부에서는 접근할 수 없습니다. 예 :
    
+
    ECMAScript 비공개 필드 (ECMAScript Private Fields)
    
+
    TypeScript 3.8에서, TypeScript는 비공개 필드를 위한 JavaScript의 새로운 문법을 지원합니다:
    
+
    class Animal {
+    #name: string;
+    constructor(theName: string) { this.#name = theName; }
+}
+
+new Animal("Cat").#name; // 프로퍼티 '#name'은 비공개 식별자이기 때문에 'Animal' 클래스 외부에선 접근할 수 없습니다.
+
    
+
    이 문법은 JavaScript 런타임에 내장되어 있으며, 각각의 비공개 필드의 격리를 더 잘 보장할 수 있습니다.
+현재 TypeScript 3.8 릴리즈 노트에 비공개 필드에 대해 자세히 나와있습니다.
    
+
    TypeScript의 private 이해하기 (Understanding TypeScript’s private)
    
+
    TypeScript에는 멤버를 포함하는 클래스 외부에서 이 멤버에 접근하지 못하도록 멤버를 private으로 표시하는 방법이 있습니다. 예:
    
 
    class Animal {
     private name: string;
     constructor(theName: string) { this.name = theName; }
 }
 
-new Animal("Cat").name; // 오류: 'name'은 private이다;
+new Animal("Cat").name; // 오류: 'name'은 비공개로 선언되어 있습니다;
 
    
-
    TypeScript는 구조적인 타입의 시스템입니다.
    두 개의 다른 타입을 비교할 때 그것들이 어디서 왔는지에 관계없이 모든 멤버의 타입이 호환 가능하다면 그 타입 자체가 호환성(compatible)이 있다고 말합니다.
    
-
    그러나 private 및 protected멤버가 있는 타입을 비교할 때 이러한 타입들은 다르게 처리합니다.
    
-
    호환성(compatible)이 있는 것으로 판단되는 두 가지 타입 중 private멤버가 있는 경우 다른 멤버는 동일한 선언에서 유래된 private멤버가 있어야 합니다.
    이것은 protected멤버에도 적용됩니다.
    
-
    실제로 이러한 기능이 어떻게 작동하는지를 더 잘 알아보기 위한 예를 살펴보겠습니다:
    
+
    TypeScript는 구조적인 타입 시스템입니다.
+두개의 다른 타입을 비교할 때 어디서 왔는지 상관없이 모든 멤버의 타입이 호환 된다면, 그 타입들 자체가 호환 가능하다고 말합니다.
    
+
    그러나 private 및 protected 멤버가 있는 타입들을 비교할 때는 타입을 다르게 처리합니다.
+호환된다고 판단되는 두 개의 타입 중 한 쪽에서 private 멤버를 가지고 있다면, 다른 한 쪽도 무조건 동일한 선언에 private 멤버를 가지고 있어야 합니다.
+이것은 protected 멤버에도 적용됩니다.
    
+
    실제로 어떻게 작동하는지 알아보기 위해 다음 예제를 살펴보겠습니다:
    
 
    class Animal {
     private name: string;
     constructor(theName: string) { this.name = theName; }
@@ -841,14 +910,16 @@ 
    pr
 let employee = new Employee("Bob");
 
 animal = rhino;
-animal = employee; // 오류: 'Animal'과 'Employee'는 호환되지 않습니다.
+animal = employee; // 오류: 'Animal'과 'Employee'은 호환될 수 없음.
 
    
-
    이 예제에서는 Animal과 Rhino가 있습니다. Rhino는 Animal의 하위 클래스입니다.
    또한 구체적으로 Animal과 같아 보이는 Employee라는 새로운 클래스를 가지고 있습니다.
    이러한 클래스들의 인스턴스들을 만들고 서로를 할당하여 어떠한 일이 발생하는지 봅시다.
    
-
    Animal과 Rhino는 Animal의 private name: string 선언으로부터 private의 형태를 공유하기 때문에 호환됩니다.
    그러나 Employee의 경우는 그렇지 않습니다.
    
-
    Employee를 Animal에 할당하려고 할 때 이 타입들은 호환되지 않는다는 오류가 발생합니다.
    Employee도 name이라는 private 멤버가 있지만 Animal에서 선언한 것이 아닙니다.
    
-
    protected 이해하기 (Understanding protected)
    
-
    protected 지정자는 private 지정자와 매우 유사하게 동작합니다.
    단 protected 멤버도 선언된 파생 클래스의 인스턴스에서 접근할 수 있습니다.  
    
-
    예를 들어
    
+
    이 예제에서는 Animal과 Animal의 하위클래스인 Rhino가 있습니다.
+Animal과 형태가 같아보이는 Employee라는 새로운 클래스도 있습니다.
+이 클래스들의 인스턴스를 생성하여 할당하고 어떻게 작동하는지 살펴보겠습니다.
+Animal과 Rhino는 Animal의 private name:string이라는 동일한 선언으로부터 private 부분을 공유하기 때문에 호환이 가능합니다. 하지만 Employee 경우는 그렇지 않습니다.
+Employee를 Animal에 할당할 때, 타입이 호환되지 않다는 오류가 발생합니다.
+Employee는 name이라는 private 멤버를 가지고 있지만, Animal에서 선언한 것이 아니기 때문입니다.
    
+
    protected 이해하기 (Understanding protected)
    
+
    protected 지정자도 protected로 선언된 멤버를 파생된 클래스 내에서 접근할 수 있다는 점만 제외하면 private지정자와 매우 유사하게 동작합니다. 예를 들면,
    
 
    class Person {
     protected name: string;
     constructor(name: string) { this.name = name; }
@@ -871,15 +942,15 @@ 
    console.log(howard.getElevatorPitch());
 console.log(howard.name); // 오류
 
    
-
    Person의 외부에서 name을 사용할 수는 없지만 Employee는 Person으로부터 파생되기 때문에 Employee의 인스턴스 메서드 내에서 여전히 사용할 수 있습니다.
    
-
    생성자 또한 protected로 표시될 수도 있습니다.
    즉 클래스를 포함하는 클래스 외부에서 클래스를 인스턴스화할 수는 없지만 확장될 수는 있습니다.
    
-
    예를 들어
    
+
    Person 외부에서 name을 사용할 수 없지만, Employee는 Person에서 파생되었기 때문에 Employee의 인스턴스 메서드 내에서는 여전히 사용할 수 있습니다.
    
+
    생성자 또한 protected로 표시될 수도 있습니다.
+이는 클래스를 포함하는 클래스 외부에서 인스턴스화 할 수 없지만 확장 할 수 있음을 의미합니다. 예를 들면,
    
 
    class Person {
     protected name: string;
     protected constructor(theName: string) { this.name = theName; }
 }
 
-// Employee는 Person을 확장할 수 있습니다
+// Employee는 Person을 확장할 수 있습니다.
 class Employee extends Person {
     private department: string;
 
@@ -894,11 +965,11 @@ 
    let howard = new Employee("Howard", "Sales");
-let john = new Person("John"); // 오류: 'Person'의 생성자는 protected입니다.
+let john = new Person("John"); // 오류: 'Person'의 생성자는 protected 입니다.
 
    
-
    Readonly 지정자 (Readonly modifier)
    
-
    readonly 키워드를 사용하여 프로퍼티들을 읽기 전용으로 만들 수 있습니다.
-읽기 전용 프로퍼티들은 선언 또는 생성자에서 초기화해야합니다.
    
+
    읽기전용 지정자 (Readonly modifier)
    
+
    readonly키워드를 사용하여 프로퍼티를 읽기전용으로 만들 수 있습니다.
+읽기전용 프로퍼티들은 선언 또는 생성자에서 초기화해야 합니다.
    
 
    class Octopus {
     readonly name: string;
     readonly numberOfLegs: number = 8;
@@ -907,24 +978,21 @@ 
    Readonly 지&#
     }
 }
 let dad = new Octopus("Man with the 8 strong legs");
-dad.name = "Man with the 3-piece suit"; // 오류! name은 readonly입니다.
+dad.name = "Man with the 3-piece suit"; // 오류! name은 읽기전용 입니다.
 
    
 
    매개변수 프로퍼티 (Parameter properties)
    
-
    마지막 예제의 Octopus 클래스에서 readonly 멤버 name과 생성자 매개변수 theName을 선언했습니다.
    그 다음 바로 name을 theName으로 설정했습니다.
    
-
    이것은 매우 일반적인 방법입니다.
    매개변수 프로퍼티(Parameter properties) 를 사용하면 한 곳에서 멤버를 생성하고 초기화할 수 있습니다.
    다음은 매개 변수 프로퍼티를 사용하여 이전에 Octopus 클래스를 추가적으로 수정합니다:
    
+
    마지막 예제의 Octopus 클래스 내에서 name이라는 읽기전용 멤버와 theName이라는 생성자 매개변수를 선언했습니다. 이는 Octopus의 생성자가 수행된 후에 theName의 값에 접근하기 위해서 필요합니다. 매개변수 프로퍼티를 사용하면 한 곳에서 멤버를 만들고 초기화할 수 있습니다. 다음은 매개변수 프로퍼티를 사용한 더 개정된 Octopus클래스입니다.
    
 
    class Octopus {
     readonly numberOfLegs: number = 8;
     constructor(readonly name: string) {
     }
 }
 
    
-
    theName을 어떻게 삭제했는지 확인하고 생성자에서 readonly name : string 매개 변수를 사용해 멤버 name을 생성하고 초기화할 수 있습니다.
    
-
    선언과 할당을 하나의 장소로 통합했습니다.
    
-
    매개변수 프로퍼티는 접근 지정자(accessibility modifier) 또는 readonly 또는 둘 모두로 생성자 매개변수를 접두어로 붙여 선언합니다.
    매개 변수 프로퍼티에 private을 사용하면 private 멤버가 선언되고 초기화됩니다.
    마찬가지로 public와 protected 그리고 readonly도 마찬가지입니다.
    
+
    생성자에 짧아진 readonly name: string 파라미터를 사용하여 theName을 제거하고 name 멤버를 생성하고 초기화했습니다. 즉 선언과 할당을 한 곳으로 통합했습니다.
    
+
    매개변수 프로퍼티는 접근 지정자나 readonly 또는 둘 모두를 생성자 매개변수에 접두어로 붙여 선언합니다. 매개변수 프로퍼티에 private을 사용하면 비공개 멤버를 선언하고 초기화합니다. 마찬가지로, public, protected, readonly도 동일하게 작용합니다.
    
 
    접근자 (Accessors)
    
-
    TypeScript는 객체의 멤버에 대한 접근을 인터셉트하는 방법으로 getters/setters를 지원합니다.
    이것을 통해 각 객체에서 멤버에 접근하는 방법을 세부적으로 제어할 수 있습니다.
    
-
    간단한 클래스에 get과 set을 사용하도록 변환해봅시다.
-먼저 getter와 setter가 없는 예제부터 시작합시다.
    
+
    TypeScript는 객체의 멤버에 대한 접근을 가로채는 방식으로 getters/setters를 지원합니다. 이를 통해 각 객체의 멤버에 접근하는 방법을 세밀하게 제어할 수 있습니다.
    
+
    간단한 클래스를 get과 set을 사용하도록 변환해봅시다. 먼저 getters와 setters가 없는 예제로 시작합니다.
    
 
    class Employee {
     fullName: string;
 }
@@ -935,9 +1003,10 @@ 
    접근자 (Accessors)
     console.log(employee.fullName);
 }
 
    
-
    사람들이 임의로 fullName을 직접 설정하는 것은 매우 편리하지만 기분 내키는 대로 이름을 바꿀 수 있다면 문제를 일으킬 수 있습니다
    
-
    이 버전에서는 employee를 수정할 수 있도록 하기 전에 사용자가 passcode를 사용할 수 있는지 확인합니다.
    이를 위해 passcode를 확인할 fullName에 대한 직접적인 권한을 set으로 교체합니다.
    앞의 예제가 계속해서 원활하게 작동하도록 하기 위해 그에 상응하는 get을 추가합니다.
    
-
    let passcode = "secret passcode";
+
    사람들이 임의로 fullName을 직접 설정할 수 있도록 허용하는 것은 매우 편리하지만, 우리는 fullName이 설정될 때 몇 가지 제약 조건이 적용되는 것을 원할 수 있습니다.
    
+
    이 버전에서는 백업 데이터베이스 필드의 최대 길이와 호환되는지 확인하기 위해 newName의 길이를 확인하는 setter를 추가합니다. 만약 최대 길이를 초과한다면, 클라이언트 코드에 문제가 있다는 것을 알리기 위해 오류를 발생시킵니다.
    
+
    기존의 기능을 유지하기 위해, fullName을 수정하지 않는 간단한 getter도 추가합니다.
    
+
    const fullNameMaxLength = 10;
 
 class Employee {
     private _fullName: string;
@@ -947,12 +1016,11 @@ 
    접근자 (Accessors)
     }
 
     set fullName(newName: string) {
-        if (passcode && passcode == "secret passcode") {
-            this._fullName = newName;
-        }
-        else {
-            console.log("오류 : employee의 무단 업데이트!");
+        if (newName && newName.length > fullNameMaxLength) {
+            throw new Error("fullName has a max length of " + fullNameMaxLength);
         }
+
+        this._fullName = newName;
     }
 }
 
@@ -962,14 +1030,11 @@ 
    접근자 (Accessors)
     console.log(employee.fullName);
 }
 
    
-
    접근자가 passcode를 확인하고 있다는 것을 입증하기 위해 passcode를 수정하고 passcode가 일치하지 않을 경우 employee에게 업데이트 권한이 없다는 경고 메시지를 받을 수 있습니다.
    
-
    접근자에 대해 알아야 할 몇 가지 주의사항:
    
-
    첫째, 접근자를 사용하려면 ECMAScript5 이상을 출력하도록 컴파일러를 설정해야 합니다.
-ECMAScript3 다운그레이드는 지원되지 않습니다.
    
-
    둘째, get과 set을 가진 접근자는 자동적으로 readonly로 추론됩니다.
    이것은 코드에서 .d.ts 파일을 생성할 때 유용합니다. 왜냐하면 프로퍼티를 변경할 수 없다는 것을 알 수 있기 때문입니다.
    
-
    정적 프로퍼티 (Static Properties)
    
-
    지금까지는 인스턴스의 클래스 멤버들에 대해서만 이야기했습니다.
    인스턴스는 인스턴스화될 때 객체에서 나타납니다.
    또한 인스턴스가 아닌 클래스 자체에 볼 수 있는 스태틱 멤버도 생성할 수 있습니다.
    
-
    이 예제에서는 모든 grid의 일반적인 값이기 때문에 origin에 스태틱을 사용합니다.
    각 인스턴스는 클래스의 이름을 미리 정의하여 이 값에 접근합니다.
    인스턴스의 접근자 앞에 this. 를 추가하는 것과 비슷하게 스태틱 접근자 앞에 Grid를 추가합니다.
    
+
    접근자가 값의 길이를 확인하고 있는지 검증하기 위해서, 10자가 넘는 이름을 할당하고 오류가 발생함을 확인할 수 있습니다.
    
+
    접근자에 대해 주의해야 할 사항:
    
+
    먼저 접근자는 ECMAScript 5 이상을 출력하도록 컴파일러를 설정해야 합니다. ECMAScript 3으로의 하향 조정은 지원되지 않습니다. 둘째, get과 set이 없는 접근자는 자동으로 readonly로 유추됩니다. 이는 프로퍼티 내의 사용자들이 변경할 수 없음을 알 수 있기 때문에 코드 내에서 .d.ts 파일을 생성할 때 유용합니다.
    
+
    전역 프로퍼티 (Static Properties)
    
+
    지금까지는 인스턴스화될 때 객체에 보이는 인스턴스 멤버에 대해서만 살펴보았습니다. 또한 우리는 인스턴스가 아닌 클래스 자체에서 보이는 전역 멤버를 생성할 수 있습니다. 이 예제에서는 모든 grid의 일반적인 값이기 때문에 origin에 static을 사용합니다. 각 인스턴스는 클래스 이름을 앞에 붙여 이 값에 접근할 수 있습니다. 인스턴스 접근 앞에 this.를 붙이는 것과 비슷하게 여기선 전역 접근 앞에 Grid.를 붙입니다.
    
 
    class Grid {
     static origin = {x: 0, y: 0};
     calculateDistanceFromOrigin(point: {x: number; y: number;}) {
@@ -987,7 +1052,7 @@ 
    &#x
 console.log(grid2.calculateDistanceFromOrigin({x: 10, y: 10}));
 
    
 
    추상 클래스 (Abstract Classes)
    
-
    추상 클래스는 다른 클래스가 파생될 수 있는 기본 클래스입니다.
    추상 클래스는 직접적으로 인스턴스화할 수 없습니다.
    인터페이스와 달리 추상 클래스는 클래스의 멤버에 대한 구현 세부 정보를 포함할 수 있습니다.
    abstract 키워드는 추상 클래스뿐만 아니라 추상 클래스 내의 추상 메서드를 정의하는 데 사용됩니다.
    
+
    추상 클래스는 다른 클래스들이 파생될 수 있는 기초 클래스입니다. 추상 클래스는 직접 인스턴스화할 수 없습니다. 추상 클래스는 인터페이스와 달리 멤버에 대한 구현 세부 정보를 포함할 수 있습니다. abstract 키워드는 추상 클래스뿐만 아니라 추상 클래스 내에서 추상 메서드를 정의하는데 사용됩니다.
    
 
    abstract class Animal {
     abstract makeSound(): void;
     move(): void {
@@ -995,7 +1060,7 @@ 
    추
     }
 }
 
    
-
    abstract으로 표시된 추상 클래스 내의 메서드는 구현을 포함하지 않으므로 파생된 클래스에서 구현해야 합니다.
    추상 메서드는 인터페이스 메서드와 유사한 구문을 사용합니다.
    둘 다 메서드 본문을 포함하지 않고 메서드를 정의합니다.
    그러나 추상 메서드는 abstract 키워드를 포함해야 하며 선택적으로 접근 지정자를 포함할 수 있습니다.
    
+
    추상 클래스 내에서 추상으로 표시된 메서드는 구현을 포함하지 않으며 반드시 파생된 클래스에서 구현되어야 합니다. 추상 메서드는 인터페이스 메서드와 비슷한 문법을 공유합니다. 둘 다 메서드 본문을 포함하지 않고 메서드를 정의합니다. 그러나 추상 메서드는 반드시 abstract 키워드를 포함해야 하며, 선택적으로 접근 지정자를 포함할 수 있습니다.
    
 
    abstract class Department {
 
     constructor(public name: string) {
@@ -1005,13 +1070,13 @@ 
    추
         console.log("Department name: " + this.name);
     }
 
-    abstract printMeeting(): void; // 파생된 클래스에서 구현해야 합니다.
+    abstract printMeeting(): void; // 반드시 파생된 클래스에서 구현되어야 합니다.
 }
 
 class AccountingDepartment extends Department {
 
     constructor() {
-        super("Accounting and Auditing"); // 파생된 클래스의 생성자는 super()를 호출해야합니다.
+        super("Accounting and Auditing"); // 파생된 클래스의 생성자는 반드시 super()를 호출해야 합니다.
     }
 
     printMeeting(): void {
@@ -1023,17 +1088,16 @@ 
    추
     }
 }
 
-let department: Department; // 좋아요: abstract 타입에 대한 참조를 만듭니다.
-department = new Department(); // 오류: 추상 클래스의 인스턴스를 생성할 수 없습니다.
-department = new AccountingDepartment(); // 좋아요: 추상적이지 않은 하위 클래스를 생성하고 할당합니다.
+let department: Department; // 추상 타입의 레퍼런스를 생성합니다
+department = new Department(); // 오류: 추상 클래스는 인스턴스화 할 수 없습니다
+department = new AccountingDepartment(); // 추상이 아닌 하위 클래스를 생성하고 할당합니다
 department.printName();
 department.printMeeting();
-department.generateReports(); // 오류: abstract 타입으로 선언된 메서드가 존재하지 않습니다.
+department.generateReports(); // 오류: 선언된 추상 타입에 메서드가 존재하지 않습니다
 
    
 
    고급 기법 (Advanced Techniques)
    
 
    생성자 함수 (Constructor functions)
    
-
    TypeScript에서 클래스를 선언하면 실제로 여러 선언이 동시에 생성됩니다.
-첫 번째 클래스의 인스턴스 타입입니다.
    
+
    TypeScript에서는 클래스를 선언하면 실제로 여러 개의 선언이 동시에 생성됩니다. 첫 번째로 클래스의 인스턴스 타입입니다.
    
 
    class Greeter {
     greeting: string;
     constructor(message: string) {
@@ -1046,12 +1110,10 @@ 
    생
 
 let greeter: Greeter;
 greeter = new Greeter("world");
-console.log(greeter.greet());
+console.log(greeter.greet()); // "Hello, world""
 
    
-
    여기서 let greeter: Greeter라고 할 때 Greeter 클래스의 인스턴스 타입으로 Greeter를 사용합니다.
    이것는 다른 객체 지향 언어를 사용하는 개발자에게는 거의 두 번째 특성입니다.
    
-
    또한 생성자 함수라고 부르는 또 다른 값을 생성하고 있습니다.
-이것은 클래스의 인스턴스를 new 할 때 호출되는 함수입니다.
    
-
    실제로 이 과정이 어떻게 진행되고 있는지 확인하기 위해 위의 예제에서 생성된 JavaScript를 살펴보겠습니다:
    
+
    여기서 let greeter: Greeter라고 할 때, Greeter 클래스의 인스턴스 타입으로 Greeter를 사용합니다. 이것은 거의 다른 객체 지향 언어를 사용하는 프로그래머들에겐 자연스러운 성질입니다.
    
+
    또한 생성자 함수라고 불리는 또 다른 값을 생성하고 있습니다. 이것은 클래스의 인스턴스를 new 할 때 호출되는 함수입니다. 실제로 어떻게 보이는지 확인하기 위해 위의 예제에서 만들어진 JavaScript를 살펴보겠습니다.
    
 
    let Greeter = (function () {
     function Greeter(message) {
         this.greeting = message;
@@ -1064,10 +1126,10 @@ 
    생
 
 let greeter;
 greeter = new Greeter("world");
-console.log(greeter.greet());
+console.log(greeter.greet()); // "Hello, world"
 
    
-
    여기서 let Greeter는 생성자 함수를 할당 받게 될 것입니다.
    new를 호출하고 이 함수를 실행하면 클래스의 인스턴스를 얻습니다.
    생성자 함수에는 클래스의 모든 스태틱 멤버 또한 포함됩니다.
    각각의 클래스를 생각하는 또 다른 방법은 인스턴스 측면과 스태틱 측면이 있다는 것입니다.
    
-
    이 차이를 보여 주기 위해 예제를 약간 수정해 보겠습니다:
    
+
    여기서, let Greeter는 생성자 함수를 할당받을 것입니다. new를 호출하고 이 함수를 실행할 때, 클래스의 인스턴스를 얻습니다. 또한 생성자 함수는 클래스의 모든 전역 변수들을 포함하고 있습니다. 각 클래스를 생각하는 또 다른 방법은 인스턴스 측면과 정적 측면이 있다는 것 입니다.
    
+
    이 차이를 보여주기 위해 예제를 수정해봅시다.
    
 
    class Greeter {
     static standardGreeting = "Hello, there";
     greeting: string;
@@ -1083,19 +1145,18 @@ 
    생
 
 let greeter1: Greeter;
 greeter1 = new Greeter();
-console.log(greeter1.greet());
+console.log(greeter1.greet()); // "Hello, there"
 
 let greeterMaker: typeof Greeter = Greeter;
 greeterMaker.standardGreeting = "Hey there!";
 
 let greeter2: Greeter = new greeterMaker();
-console.log(greeter2.greet());
+console.log(greeter2.greet()); // "Hey there!"
 
    
-
    이 예제에서 greeter1은 이전과 비슷하게 작동합니다.
    Greeter 클래스를 인스턴스화하고 이 객체를 사용합니다.
    이것은 전에 본 적이 있는 것입니다.
    
-
    그런 다음 그 클래스를 직접 사용합니다.
    여기서 greeterMaker라는 새로운 변수를 만듭니다.
    이 변수는 클래스 자체를 유지하거나 생성자 함수라고 하는 또 다른 방법으로 설명합니다.  
    
-
    여기서는 typeof Greeter를 사용합니다.
    즉 "인스턴스 타입이 아닌 "Greeter 클래스 자체의 타입을 제공합니다".
    또는 더 정확하게 생성자 함수의 타입인 "Greeter라는 symbol 타입을 제공합니다".
    이 타입에는 Greeter 클래스의 인스턴스를 생성하는 생성자와 함께 Greeter의 모든 스태틱 멤버가 포함됩니다.
    greeterMaker에 new를 사용하는 것을 보여 주며 Greeter의 새로운 인스턴스를 생성하고 이전과 같이 호출합니다.
    
-
    클래스를 인터페이스로 사용하기 (Using a class as an interface)
    
-
    앞서 언급한 것처럼 클래스 선언은 두 가지를 생성합니다: 클래스의 인스턴스를 나타내는 타입과 생성자 함수
    클래스는 타입을 작성하기 때문에 인터페이스를 사용할 수 있는 동일한 위치에서 타입을 사용할 수 있습니다.
    
+
    이 예제에서 greeter1은 이전과 비슷하게 작동합니다. Greeter 클래스를 인스턴스화하고 이 객체를 사용합니다. 이것은 전에 본 것입니다.
    
+
    다음으로, 클래스를 직접 사용합니다. 여기서 greeterMaker라는 새로운 변수를 생성합니다. 이 변수는 클래스 자체를 유지하거나 생성자 함수를 다르게 설명합니다. 여기서 typeof Greeter를 사용하여 인스턴스 타입이 아닌 "Greeter 클래스 자체의 타입을 제공합니다". 혹은 더 정확하게 생성자 함수의 타입인 "Greeter라는 심볼의 타입을 제공합니다". 이 타입은 Greeter 클래스의 인스턴스를 만드는 생성자와 함께 Greeter의 모든 정적 멤버를 포함할 것입니다. greeterMaker에 new를 사용함으로써 Greeter의 새로운 인스턴스를 생성하고 이전과 같이 호출합니다.
    
+
    인터페이스로써 클래스 사용하기 (Using a class as an interface)
    
+
    앞서 언급한 것처럼, 클래스 선언은 클래스의 인스턴스를 나타내는 타입과 생성자 함수라는 두 가지를 생성합니다. 클래스는 타입을 생성하기 때문에 인터페이스를 사용할 수 있는 동일한 위치에서 사용할 수 있습니다.
    
 
    class Point {
     x: number;
     y: number;
@@ -1150,7 +1211,7 @@ 
    No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"클래스","level":"3.4","depth":1,"next":{"title":"함수","level":"3.5","depth":1,"path":"pages/Functions.md","ref":"pages/Functions.md","articles":[]},"previous":{"title":"인터페이스","level":"3.3","depth":1,"path":"pages/Interfaces.md","ref":"pages/Interfaces.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Classes.md","mtime":"2019-06-14T05:59:13.387Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"클래스","level":"3.4","depth":1,"next":{"title":"함수","level":"3.5","depth":1,"path":"pages/Functions.md","ref":"pages/Functions.md","articles":[]},"previous":{"title":"인터페이스","level":"3.3","depth":1,"path":"pages/Interfaces.md","ref":"pages/Interfaces.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Classes.md","mtime":"2020-04-22T15:29:36.172Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Compiler Options in MSBuild.html b/pages/Compiler Options in MSBuild.html
index a47ca0cd..9886e260 100644
--- a/pages/Compiler Options in MSBuild.html	
+++ b/pages/Compiler Options in MSBuild.html	
@@ -76,7 +76,7 @@
     
     
     
-    
+    
     
 
     
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
    • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
  • 
+        
  • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
    • 
+    
+        
  • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
  • 릴리즈 노트
    • 
+        
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
    • 
+    
+
+    
 
     
  • 
 
@@ -1144,7 +1190,7 @@ 
    No results matching "
+                
                     
                 
                 
@@ -1160,7 +1206,7 @@ 
    No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"MSBuild에서의 컴파일러 옵션","level":"5.3","depth":1,"next":{"title":"빌드 도구와 통합","level":"5.4","depth":1,"path":"pages/Integrating with Build Tools.md","ref":"pages/Integrating with Build Tools.md","articles":[]},"previous":{"title":"컴파일러 옵션","level":"5.2","depth":1,"path":"pages/Compiler Options.md","ref":"pages/Compiler Options.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Compiler Options in MSBuild.md","mtime":"2019-06-14T05:32:52.235Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"MSBuild에서의 컴파일러 옵션","level":"5.4","depth":1,"next":{"title":"빌드 도구와 통합","level":"5.5","depth":1,"path":"pages/Integrating with Build Tools.md","ref":"pages/Integrating with Build Tools.md","articles":[]},"previous":{"title":"프로젝트 레퍼런스","level":"5.3","depth":1,"path":"pages/Project References.md","ref":"pages/Project References.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Compiler Options in MSBuild.md","mtime":"2020-04-22T13:02:03.072Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Compiler Options.html b/pages/Compiler Options.html
index 89979d23..d3f62933 100644
--- a/pages/Compiler Options.html	
+++ b/pages/Compiler Options.html	
@@ -73,7 +73,7 @@
     
 
     
-    
+    
     
     
     
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
    • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
  • 
+        
  • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
    • 
+    
+        
  • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
  • 릴리즈 노트
    • 
+        
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
    • 
+    
+
+    
 
     
  • 
 
@@ -1221,7 +1267,7 @@ 
    No results matching "
                 
                 
-                
+                
                     
                 
                 
@@ -1232,7 +1278,7 @@ 
    No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"컴파일러 옵션","level":"5.2","depth":1,"next":{"title":"MSBuild에서의 컴파일러 옵션","level":"5.3","depth":1,"path":"pages/Compiler Options in MSBuild.md","ref":"pages/Compiler Options in MSBuild.md","articles":[]},"previous":{"title":"tsconfig.json","level":"5.1","depth":1,"path":"pages/tsconfig.json.md","ref":"pages/tsconfig.json.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Compiler Options.md","mtime":"2019-06-14T05:32:52.235Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"컴파일러 옵션","level":"5.2","depth":1,"next":{"title":"프로젝트 레퍼런스","level":"5.3","depth":1,"path":"pages/Project References.md","ref":"pages/Project References.md","articles":[]},"previous":{"title":"tsconfig.json","level":"5.1","depth":1,"path":"pages/tsconfig.json.md","ref":"pages/tsconfig.json.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Compiler Options.md","mtime":"2020-04-22T13:02:03.074Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Declaration Merging.html b/pages/Declaration Merging.html
index 0fe662b5..3963b1f2 100644
--- a/pages/Declaration Merging.html	
+++ b/pages/Declaration Merging.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
    • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
  • 
+        
  • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
    • 
+    
+        
  • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
  • 릴리즈 노트
    • 
+        
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
    • 
+    
+
+    
 
     
  • 
 
@@ -711,11 +757,19 @@ 
    
     
                                 
    
                                 
-                                
    소개
    
-
    TypeScript의 고유한 개념 중 일부는 타입 레벨에서 JavaScript 객체의 형태를 설명합니다.
    특히 TypeScript에서의 고유한 예로는 '선언 병합'이라는 개념이 있습니다.
    이 개념을 이해하는 것은 기존 JavaScript를 사용할 때 이점을 제공할 것입니다.
    또한 고급 추상화 개념에 대한 문을 열어줍니다.
    
-
    이 아티클의 목적인 "선언 병합"은 컴파일러가 동일한 이름으로 선언된 두개의 독립된 선언을 하나의 정의로 병합하는 것을 의미합니다.
    이 병합된 정의에는 원래 선언의 두 가지 기능이 있습니다.
    어떠한 수의 선언이든 병합할 수 있습니다. 단지 두 가지 선언에 제한되지 않습니다.
    
-
    기본 개념 (Basic Concepts)
    
-
    TypeScript에서 선언은 다음 세 가지 중 하나 이상의 엔티티를 생성합니다: 네임스페이스, 타입 또는 값
    네임스페이스-생성 선언은 점 표기법을 사용하여 접근하는 이름이 포함된 네임스페이스를 생성합니다.
    타입-생성 선언은 다음과 같습니다: 선언된 형태로 표시되고 주어진 이름에 바인딩 되는 타입을 작성합니다.
    마지막으로, 값-생성 선언은 출력된 JavaScript에서 볼 수 있는 값을 만듭니다.
    
+                                
    소개 (Introduction)
    
+
    TypeScript의 독특한 개념들 중 일부는 타입 레벨에서 JavaScript 객체의 형태를 설명합니다.
+그중 TypeScript만의 특별한 예로 '선언 병합' 개념이 있습니다.
+이 개념을 이해한다면 기존의 JavaScript와 작업을 할 때 이점이 많아집니다.
+또한 이 개념은 고급 추상화 개념으로의 문을 열어줄 것입니다.
    
+
    본론으로 돌아가서, "선언 병합"은 컴파일러가 같은 이름으로 선언된 두 개의 개별적인 선언을 하나의 정의로 병합하는 것을 뜻합니다.
+이 병합된 정의는 원래 두 선언 각각의 기능을 모두 갖게 됩니다.
+병합할 선언이 몇 개든 상관없습니다; 이 개념은 단지 두 개의 선언만 합치도록 제한하지 않습니다.
    
+
    기본 사용법 (Basic Concepts)
    
+
    TypeScript에서 선언은 네임스페이스, 타입, 값 중 한 종류 이상의 엔티티를 생성합니다.
+네임스페이스-생성 선언은 점으로 구분된 표기법을 사용하여 접근할 이름을 가진 네임스페이스를 생성합니다.
+타입-생성 선언은 선언된 형태로 표시되며 지정된 이름에 바인딩 된 타입을 생성합니다.
+마지막으로 값-생성 선언은 출력된 JavaScript에서 확인할 수 있는 값을 생성합니다.
    
 
@@ -770,9 +824,10 @@ 
    기본 ¬
 
    
 
 
    
 
 
    
-
    각 선언으로 생성된 내용을 이해하면 선언 병합을 수행할 때 병합되는 내용을 이해하는 데 도움이 됩니다.
    
+
    각 선언으로 생성된 결과물을 이해하면, 선언 병합을 할 때 병합된 결과물을 이해하는 데에 도움이 됩니다.
    
 
    인터페이스 병합 (Merging Interfaces)
    
-
    가장 단순하고 아마도 가장 일반적인 타입의 선언 병합은 인터페이스 병합입니다.
    가장 기본적인 수준에서 이 병합은 두 선언의 멤버를 기계적으로 같은 이름의 단일 인터페이스에 결합합니다.
    
+
    가장 일반적이고 간단한 선언 병합 유형은 인터페이스 병합입니다.
+가장 기본적인 수준에서, 병합은 각 선언의 멤버를 같은 이름의 인터페이스에 기계적으로 결합합니다.
    
 
    interface Box {
     height: number;
     width: number;
@@ -784,9 +839,12 @@ 
    let box: Box = {height: 5, width: 6, scale: 10};
 
    
-
    인터페이스의 비-함수 멤버는 고유해야 합니다.
    고유하지 않다면 같은 타입이어야 합니다.
    컴파일러는 인터페이스가 모두 같은 이름이지만 다른 타입의 비-함수 멤버를 선언하는 경우 오류를 발생시킵니다.
    
-
    함수 멤버의 경우 같은 이름의 각 함수 멤버가 같은 함수의 오버로드를 설명하는 것으로 간주합니다.
    또한 후위의 인터페이스 A와 인터페이스 A를 병합하는 경우에는 두 번째 인터페이스가 첫 번째 인터페이스보다 우선순위가 더 높다는 점이 주목됩니다.
    
-
    예를 들어 다음과 같습니다:
    
+
    각 인터페이스의 비-함수 멤버는 고유해야 합니다.
+만약 고유하지 않다면, 모두 같은 타입이어야 합니다.
+인터페이스가 같은 이름이지만 다른 타입을 가진 비-함수 멤버가 있을 경우, 컴파일러는 오류를 일으킵니다.
    
+
    함수 멤버의 경우, 이름이 같을 경우 동일한 함수에 대한 오버로드하는 것으로 처리합니다.
+또한 A 인터페이스와 나중의 A 인터페이스를 병합하는 경우, 두 번째 인터페이스가 더 높은 우선순위를 갖게 됩니다.
    
+
    이 말은, 예를 들어:
    
 
    interface Cloner {
     clone(animal: Animal): Animal;
 }
@@ -800,7 +858,7 @@ 
    clone(animal: Cat): Cat;
 }
 
    
-
    세 개의 인터페이스가 병합되어 단일 선언을 생성합니다:
    
+
    위의 세 인터페이스는 병합되어 다음과 같이 하나의 새로운 선언을 생성합니다:
    
 
    interface Cloner {
     clone(animal: Dog): Dog;
     clone(animal: Cat): Cat;
@@ -808,9 +866,10 @@ 
    clone(animal: Animal): Animal;
 }
 
    
-
    각 그룹의 요소는 같은 순서를 유지하지만 그룹 자체는 나중에 오버로드가 발생한 것이 가장 먼저 병합됩니다.
    
-
    이 규칙에 대한 한가지 예외는 특수한 시그니처(specialized signatures)입니다.
    시그니처의 타입이 단일 문자열 리터럴 타입(예 : 문자열 리터럴의 유니온이 아닌)인 매개 변수가 있는 경우 병합된 오버로드 목록의 맨 위로 버블링됩니다.
    
-
    예를 들어 다음 인터페이스가 함께 병합됩니다:
    
+
    각 그룹의 요소는 동일한 순서를 유지하지만, 그룹 자체는 나중에 병합되어 오버로드 될수록 첫 번째에 위치하는 것에 유의하세요.
    
+
    그러나 이 규칙엔 특수 시그니처라는 예외가 존재합니다.
+시그니처에 단일 문자열 리터럴 타입(예: 문자열 리터럴의 유니언이 아닌 경우)인 매개변수가 있을 경우, 시그니처는 병합된 오버로드 목록의 맨 위로 올라오게 됩니다.
    
+
    예를 들어, 아래의 인터페이스들이 병합됩니다:
    
 
    interface Document {
     createElement(tagName: any): Element;
 }
@@ -823,7 +882,7 @@ 
    createElement(tagName: "canvas"): HTMLCanvasElement;
 }
 
    
-
    Document의 병합된 선언은 다음과 같습니다:
    
+
    Document의 병합된 선언은 다음과 같이 생성합니다:
    
 
    interface Document {
     createElement(tagName: "canvas"): HTMLCanvasElement;
     createElement(tagName: "div"): HTMLDivElement;
@@ -833,10 +892,11 @@ 
    네임스페이스 병합 (Merging Namespaces)
    
-
    인터페이스와 마찬가지로 같은 이름의 네임 스페이스도 해당 멤버를 병합합니다.
    네임 스페이스는 네임 스페이스와 값을 모두 생성하기 때문에 두 네임 스페이스가 어떻게 병합되는지 이해해야 합니다.
    
-
    네임 스페이스를 병합하기 위해 각 네임스페이스에 선언된 exported 인터페이스의 타입 정의 자체가 병합되며 내부에 병합된 인터페이스 정의가 있는 단일 네임스페이스를 형성합니다.
    
-
    네임 스페이스 값을 병합하려면 각 선언 사이트에 지정된 이름의 네임 스페이스가 이미 있는 경우 기존 네임 스페이스를 가져와 두 번째 네임 스페이스의 내보낸 멤버를 첫 번째 네임스페이스에 추가하여 네임 스페이스를 확장합니다.
    
-
    이 예에서는 Animals의 병합을 선언합니다:
    
+
    인터페이스와 마찬가지로, 같은 이름을 가진 네임스페이스도 멤버를 병합합니다.
+네임스페이스는 네임스페이스와 값을 둘 다 생성하기 때문에, 이들이 어떻게 병합하는지 이해해야 합니다.
    
+
    네임스페이스를 병합하기 위해 각 네임스페이스에 선언된 내보낸 인터페이스로부터 타입 정의가 병합되며, 내부에 병합된 인터페이스 정의들이 있는 단일 네임스페이스를 형성됩니다.
    
+
    네임스페이스 값을 병합하려면, 각 선언 위치에서 이미 지정된 이름의 네임스페이스가 있을 경우, 기존 네임스페이스에 두 번째 네임스페이스의 내보낸 멤버를 첫 번째에 추가하여 네임스페이스 값을 확장됩니다.
    
+
    이 예제에서 Animals의 선언 병합:
    
 
    namespace Animals {
     export class Zebra { }
 }
@@ -846,7 +906,7 @@ 
    export class Dog { }
 }
 
    
-
    다음과 같습니다.
    
+
    다음과 같습니다:
    
 
    namespace Animals {
     export interface Legged { numberOfLegs: number; }
 
@@ -854,9 +914,9 @@ 
    export class Dog { }
 }
 
    
-
    병합된 네임스페이스의 모델은 유용한 출발점이지만 내보내지 않은(non-exported) 멤버에 무슨 일이 일어나는지 이해할 필요가 있습니다.
    내보낼 수 없는 멤버는 원래 (병합되지 않은) 네임 스페이스에서만 볼 수 있습니다.
    즉 병합 후에는 다른 선언에서 가져온 병합된 멤버는 내보낼 수 없는 멤버를 볼 수 없습니다.
-내보내지 않은 멤버는 원래 네임스페이스에서만 볼 수 있습니다(병합되지 않음).
    즉 병합 후에 다른 선언에서 가져온 병합된 멤버는 내보내지 않은 멤버를 볼 수 없습니다.
    
-
    이 예제에서 이것을 더 명확하게 볼 수 있습니다:
    
+
    이러한 네임스페이스 병합의 모델은 좋은 출발점이지만, 우리는 export 되지 않은 멤버에 대해 무슨 일이 일어나는지 이해할 필요가 있습니다.
+export 되지 않은 멤버는 원래의(병합되지 않은) 네임스페이스에서만 볼 수 있습니다. 이는 병합된 후에 다른 선언으로부터 합쳐진 멤버는 export 되지 않은 멤버를 볼 수 없다는 것을 의미합니다.
    
+
    이 예제에서 더 명확하게 확인할 수 있습니다:
    
 
    namespace Animal {
     let haveMuscles = true;
 
@@ -867,15 +927,18 @@ 
    namespace Animal {
     export function doAnimalsHaveMuscles() {
-        return haveMuscles;  // <-- 오류, haveMuscles는 여기에 표시되지 않습니다.
+        return haveMuscles;  // 오류, haveMuscles는 이곳에서 액세스 할 수 없습니다.
     }
 }
 
    
-
    haveMuscles가 exported되지 않았기 때문에 동일하게 병합되지 않은 네임스페이스를 공유하는 animalsHaveMuscles 함수만 이 심볼을 볼 수 있습니다.
    doAnimalsHaveMuscles 함수는 병합된 Animal 네임스페이스의 일부임에도 불구하고 exported 되지 않은 멤버를 볼 수 없습니다.
    
-
    클래스, 함수 그리고 열거형 병합 (Merging Namespaces with Classes, Functions, and Enums)
    
-
    네임스페이스는 다른 타입의 선언과도 통합이 가능할 정도로 유연합니다.
    이렇게 하려면 네임스페이스 선언이 병합할 선언을 따라야 합니다.
    결과 선언에는 두 선언 타입의 프로퍼티가 있습니다.
    TypeScript는 이 기능을 사용하여 JavaScript의 일부 패턴과 다른 프로그래밍 언어를 모델링 합니다.
    
-
    클래스와 네임스페이스 병합 (Merging Namespaces with Classes)
    
-
    이는 사용자에게 내부(inner) 클래스를 설명하는 방법을 제공합니다.
    
+
    haveMuscles이 export 되지 않아서, 동일하게 병합되지 않은 네임스페이스를 공유하는 animalsHaveMuscles 함수만 이 심벌을 볼 수 있습니다.
+doAnimalsHaveMuscles 함수가 병합된 Animal의 멤버일지라도, 내보내지 않은 멤버는 볼 수 없습니다.
    
+
    클래스, 함수, 열거형과 네임스페이스 병합 (Merging Namespaces with Classes, Functions, and Enums)
    
+
    네임스페이스는 다른 타입의 선언과 병합할 수 있을 정도로 유연합니다.
+이를 위해선, 네임스페이스의 선언은 병합할 선언을 따라야 합니다. 결과 선언에는 두 타입의 프로퍼티를 모두 갖습니다.
+TypeScript는 이를 통해 JavaScript 및 기타 프로그래밍 언어의 패턴을 모델링 합니다.
    
+
    네임스페이스와 클래스 병합 (Merging Namespaces with Classes)
    
+
    이 부분에서는 내부 클래스를 설명하는 방법을 제공합니다.
    
 
    class Album {
     label: Album.AlbumLabel;
 }
@@ -883,8 +946,11 @@ 
    export class AlbumLabel { }
 }
 
    
-
    병합된 멤버의 가시성 규칙은 '네임스페이스 병합' 섹션에 설명된 것과 같으므로 병합된 클래스를 보려면 AlbumLabel 클래스를 export 해야 합니다.
    최종 결과는 다른 클래스 내부에서 관리되는 클래스입니다.
    네임스페이스를 사용하여 기존 클래스에 더 많은 정적 멤버를 추가할 수도 있습니다.
    
-
    내부 클래스 패턴 외에도 함수를 생성한 다음 함수에 프로퍼티를 추가하여 함수를 확장하는 JavaScript 방법에 익숙할 수도 있습니다.
    TypeScript는 이러한 타입을 안전한(type-safe) 방법으로 정의하기 위해 선언 병합을 사용합니다.
    
+
    병합된 멤버의 가시성 규칙은 '네임스페이스 병합' 섹션에서 설명한 것과 같으므로, AlbumLabel 클래스를 export 해야 병합된 클래스를 볼 수 있습니다.
+최종 결과물은 다른 클래스 내에서 관리되는 클래스입니다.
+또한 네임스페이스를 사용하여 기존 클래스에 더 많은 정적 멤버를 추가할 수도 있습니다.
    
+
    내부 클래스 패턴 이외에도, JavaScript에서 함수를 생성한 후 프로퍼티를 추가하여 함수를 확장하는 것에도 익숙할 것입니다.
+TypeScript는 선언 병합을 통해 타입을 안전하게 보존하며 정의할 수 있습니다.
    
 
    function buildLabel(name: string): string {
     return buildLabel.prefix + name + buildLabel.suffix;
 }
@@ -894,9 +960,9 @@ 
    export let prefix = "Hello, ";
 }
 
-alert(buildLabel("Sam Smith"));
+console.log(buildLabel("Sam Smith"));
 
    
-
    마찬가지로 네임스페이스를 사용하여 정적 멤버를 포함하는 열거형을 확장할 수 있습니다:
    
+
    마찬가지로, 네임스페이스를 정적 멤버의 열거형을 확장할 수 있습니다:
    
 
    enum Color {
     red = 1,
     green = 2,
@@ -921,22 +987,30 @@ 
    허용되지 않는 병합 (Disallowed Merges)
    
-
    TypeScript에서는 일부 병합이 허용되지 않습니다.
    현재 클래스는 다른 클래스 또는 변수와 병합할 수 없습니다.
    클래스 병합을 모방하는 방법에 대한 자세한 내용은 TypeScript의 Mixins 섹션을 참조하세요.
    
-
    모듈 확대 (Module Augmentation)
    
-
    JavaScript 모듈은 병합을 지원하지 않지만 기존 객체를 가져와서 업데이트할 수 있습니다.
    Observable 예제를 살펴봅시다:
    
-
    // observable.js
+
    TypeScript에서 모든 병합이 허용되는 것은 아닙니다.
+현재로선, 클래스는 다른 클래스 혹은 변수와 병합할 수 없습니다.
+클래스 병합을 대체하려면, TypeScript의 믹스인 섹션을 참고하세요.
    
+
    모듈 보강 (Module Augmentation)
    
+
    JavaScript는 모듈 병합을 지원하지 않지만, 기존 객체를 가져와 업데이트하여 패치 할 수 있습니다.
+아래의 장난감 Observable 예시를 살펴보겠습니다:
    
+
    // observable.ts
 export class Observable<T> {
-    // ... 구현은 숙제로 남겨놨습니다 ...
+    // ... 구현은 여러분의 몫으로 남겨놓겠습니다 ...
 }
 
-// map.js
+// map.ts
 import { Observable } from "./observable";
 Observable.prototype.map = function (f) {
-    // ... 또 다른 숙제
+    // ... 여러분을 위한 또 다른 숙제
 }
 
    
-
    이것은 TypeScript에서도 잘 작동하지만 컴파일러는 Observable.prototype.map에 대해 알지 못합니다.
    이런 경우 모듈 확대를 사용하여 컴파일러에 다음에 대해 알릴 수 있습니다:
    
-
    // observable.ts는 그대로 유지됩니다.
+
    이는 TypeScript에서 잘 동작하지만, 컴파일러는 Observable.prototype.map에 대해 알지 못합니다.
+모듈 보강을 통해 컴파일러에게 정보를 알려줄 수 있습니다:
    
+
    // observable.ts
+export class Observable<T> {
+    // ... 구현은 여러분의 몫으로 남겨놓겠습니다 ...
+}
+
 // map.ts
 import { Observable } from "./observable";
 declare module "./observable" {
@@ -945,7 +1019,7 @@ 
    모듈
     }
 }
 Observable.prototype.map = function (f) {
-    // ... 또 다른 숙제
+    // ... 여러분을 위한 또 다른 숙제
 }
 
 
@@ -955,12 +1029,19 @@ 
    모듈
 let o: Observable<number>;
 o.map(x => x.toFixed());
 
    
-
    모듈 이름은 import/export의 모듈 지정자와 같은 방법으로 해석됩니다.
    자세한 내용은 모듈을 참조하세요.
    확대되는 선언은 마치 원본과 같은 파일에 선언된 것처럼 병합됩니다.
    그러나 확대에서 새로운 최상위 레벨 선언을 새롭게 할 수는 없습니다. -- 기존 선언에 패치 만하면 됩니다.
    
-
    전역 확대 (Global augmentation)
    
-
    모듈 내부에서 전역 스코프 선언을 추가할 수도 있습니다.
    
+
    모듈 이름은 import/export의 모듈 지정자와 같은 방법으로 해석됩니다.
+자세한 내용은 모듈을 참고하세요.
+그 다음 보강된 선언은 마치 원본과 같은 파일에서 선언된 것처럼 병합됩니다.
    
+
    그러나, 두 가지 제한 사항을 명심하세요:
    
+
      
+
    1. 보강에 새로운 최상위 선언을 할 수 없습니다 -- 기존 선언에 대한 패치만 가능합니다.
      2. 
+
    2. default export 는 보강할 수 없으며, 이름을 갖는 export 만 보강할 수 있습니다.(해당 이름으로 확장시켜야 하며, default는 예약어입니다 - 자세한 내용은 #14080을 참고하세요)
      3. 
+
    
+
    전역 보강 (Global augmentation)
    
+
    모듈 내부에서 전역 범위에 선언을 추가할 수도 있습니다:
    
 
    // observable.ts
 export class Observable<T> {
-    // ... 여전히 구현되지 않고 있습니다 ...
+    // ... 여전히 구현해놓지 않았습니다 ...
 }
 
 declare global {
@@ -973,7 +1054,7 @@ 
    전역
     // ...
 }
 
    
-
    전역 확대는 모듈 확대와 같은 작동 및 제한 사항을 가집니다.
    
+
    전역 보강 또한 모듈 보강과 동일한 제한 사항을 갖습니다.
    
 
                                 
                                 
    
@@ -1017,7 +1098,7 @@ 
    No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"선언 병합","level":"3.17","depth":1,"next":{"title":"JSX","level":"3.18","depth":1,"path":"pages/JSX.md","ref":"pages/JSX.md","articles":[]},"previous":{"title":"모듈 해석","level":"3.16","depth":1,"path":"pages/Module Resolution.md","ref":"pages/Module Resolution.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Declaration Merging.md","mtime":"2019-06-14T05:32:52.236Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"선언 병합","level":"3.17","depth":1,"next":{"title":"JSX","level":"3.18","depth":1,"path":"pages/JSX.md","ref":"pages/JSX.md","articles":[]},"previous":{"title":"모듈 해석","level":"3.16","depth":1,"path":"pages/Module Resolution.md","ref":"pages/Module Resolution.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Declaration Merging.md","mtime":"2020-04-22T15:29:36.172Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Decorators.html b/pages/Decorators.html
index a30b2554..d054e436 100644
--- a/pages/Decorators.html
+++ b/pages/Decorators.html
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
    • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
  • 
+        
  • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
    • 
+    
+        
  • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
  • 릴리즈 노트
    • 
+        
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
    • 
+    
+
+    
 
     
  • 
 
@@ -711,13 +757,15 @@ 
    
     
                                 
    
                                 
-                                
    소개
    
-
    TypeScript와 ES6의 클래스가 도입됨에 따라 클래스 및 클래스 멤버에 어노테이션 또는 변경을 지원하기 위해 추가적인 기능이 필요한 일부 상황이 있습니다.
    데코레이터는 클래스 선언과 멤버에 대한 어노테이션과 메타-프로그래밍 구문을 모두 추가할 수 있는 방법을 제공합니다.
    데코레이터는 JavaScript의 stage 2 제안이며 TypeScript의 실험적인 기능으로 사용할 수 있습니다.
    
+                                
    소개 (Introduction)
    
+
    TypeScript 및 ES6에 클래스가 도입됨에 따라, 클래스 및 클래스 멤버에 어노테이션을 달거나 수정하기 위해 추가 기능이 필요한 특정 시나리오가 있습니다.
+데코레이터는 클래스 선언과 멤버에 어노테이션과 메타-프로그래밍 구문을 추가할 수 있는 방법을 제공합니다.
+데코레이터는 JavaScript에 대한 2단계 제안이며 TypeScript의 실험적 기능으로 이용 가능합니다.
    
 
    
-
    주의사항  데코레이터는 향후 변경될 수 있는 실험적 기능입니다.
    
+
    참고  데코레이터는 향후 릴리스에서 변경될 수 있는 실험적인 기능입니다.
    
 
    
-
    데코레이터에 대한 실험적인 지원을 사용하려면 커맨드 라인이나 tsconfig.json에서 experimentalDecorators 컴파일러 옵션을 사용하도록 활성화해야 합니다:
    
-
    커맨드 라인:
    
+
    데코레이터에 대한 실험적 지원을 활성화하려면 명령줄 또는 tsconfig.json에서 experimentDecorators 컴파일러 옵션을 활성화해야합니다:
    
+
    명령줄 (Command Line):
    
 
    tsc --target ES5 --experimentalDecorators
 
    
 
    tsconfig.json:
    
@@ -728,49 +776,51 @@ 
    소개
    
     }
 }
 
    
-
    데코레이터
    
-
    데코레이터는 클래스 선언, 메서드, 접근제어자, 프로퍼티 또는 매개변수에 첨부될 수 있는 특별한 종류의 선언입니다.
    데코레이터는 @표현식의 형태를 사용하는데, 여기서 표현식은 데코레이팅된 선언에 대한 정보와 함께 런타임에 호출될 함수로 평가되어야 합니다.  
    
-
    예를 들어, 데코레이터 @sealed을 사용하여 다음과 같이 sealed 함수를 작성할 수 있습니다:
    
+
    데코레이터 (Decorators)
    
+
    데코레이터는 클래스 선언, 메서드, 접근자, 프로퍼티 또는 매개 변수에 첨부할 수 있는 특수한 종류의 선언입니다.
+데코레이터는 @expression 형식을 사용합니다. 여기서 expression은 데코레이팅 된 선언에 대한 정보와 함께 런타임에 호출되는 함수여야 합니다.
    
+
    예를 들어, 데코레이터 @sealed를 사용하면 다음과 같이 sealed 함수를 작성할 수 있습니다.
    
 
    function sealed(target) {
-    // 'target'으로 뭐든 해보세요 ...
+    // 'target' 변수와 함께 무언가를 수행합니다.
 }
 
    
 
    
-
    주의사항  아래의 클래스 데코레이터에서 데코레이터에 대한 더욱 자세한 예제를 볼 수 있습니다.
    
+
    참고  아래 데코레이터 클래스에서 더 자세한 데코레이터 예제를 볼 수 있습니다.
    
 
    
-
    데코레이터 팩토리
    
-
    선언에 데코레이터를 적용하는 방법을 커스터마이징하고 싶다면 데코레이터 팩토리를 작성할 수 있습니다.
    Decorator Factory는 간단히 런타임에 데코레이터에 의해 호출될 표현식을 반환하는 함수입니다.
    
-
    다음과 같은 방식으로 데코레이터 팩토리를 작성할 수 있습니다:
    
-
    function color(value: string) { // 이것은 데코레이터 팩토리입니다
-    return function (target) { // 이것은 데코레이터입니다
-        // 'target'과 'value'로 뭐든 해보세요...
+
    데코레이터 팩토리 (Decorator Factories)
    
+
    데코레이터가 선언에 적용되는 방식을 원하는 대로 바꾸고 싶다면 데코레이터 팩토리를 작성할 수 있습니다. 데코레이터 팩토리는 단순히 데코레이터가 런타임에 호출할 표현식을 반환하는 함수입니다.
    
+
    다음과 같은 방식으로 데코레이터 팩토리를 작성할 수 있습니다.
    
+
    function color(value: string) { // 데코레이터 팩토리
+    return function (target) { // 데코레이터
+        // 'target'과 'value' 변수를 가지고 무언가를 수행합니다.
     }
 }
 
    
 
    
-
    주의사항  아래의 메서드 데코레이터에서 데코레이터 팩토리에 대한 더욱 자세한 예제를 볼 수 있습니다.
    
+
    참고  아래 메서드 데코레이터에서 데코레이터 팩토리에 대한 자세한 예를 볼 수 있습니다.
    
 
    
-
    데코레이터 구성
    
-
    다음 예제처럼 여러 데코레이터를 선언에 적용 할 수 있습니다:
    
+
    데코레이터 합성 (Decorator Composition)
    
+
    다음 예제와 같이 선언에 여러 데코레이터를 적용할 수 있습니다.
    
 
      
-
    • 한 줄에:
      
+
    • 단일 행일 경우:
      
 
      @f @g x
 
      
 
      • 
-
    • 여러 줄에:
      
+
    • 여러 행일 경우:
      
 
      @f
 @g
 x
 
      
 
      • 
 
    
-
    여러 데코레이터가 단일 선언에 적용되는 경우 평가는 수학에서의 함수 구성과 유사합니다.
    이 모델에서 함수 f와 g을 구성할 때, 결과적인 합성 (f ∘ g)(x)은(는) f(g(x))와 동일합니다.
    
-
    따라서 TypeScript의 단일 선언에서 여러 데코레이터를 평가할 때 다음 단계를 수행합니다:
    
+
    여러 데코레이터가 단일 선언에 적용되는 경우는 수학의 합성 함수와 유사합니다.
+이 모델에서 함수 f와 g을 합성할 때 (f∘g)(x)의 합성 결과는 f(g(x))와 같습니다.
    
+
    따라서 TypeScript에서 단일 선언에서 여러 데코레이터를 사용할 때 다음 단계가 수행됩니다.
    
 
      
-
    1. 각 데코레이터에 대한 표현식은 위에서 아래로 평가됩니다.
      2. 
-
    2. 그런 다음 결과는 아래에서 위로 함수를 호출합니다.
      3. 
+
    3. 각 데코레이터의 표현은 위에서 아래로 평가됩니다.
      4. 
+
    4. 그런 다음 결과는 아래에서 위로 함수로 호출됩니다.
      5. 
 
    
-
    데코레이터 팩토리를 사용하려면 다음 예제에서 이 평가 순서를 관찰할 수 있습니다:
    
+
    데코레이터 팩토리를 사용하는 경우 다음 예제를 통해 이 수행 순서를 관찰 할 수 있습니다.
    
 
    function f() {
     console.log("f(): evaluated");
     return function (target, propertyKey: string, descriptor: PropertyDescriptor) {
@@ -791,30 +841,31 @@ 
    데Ï
     method() {}
 }
 
    
-
    그러면 이 출력을 콘솔에 출력합니다:
    
+
    이는 결과를 콘솔에 출력합니다.
    
 
    f(): evaluated
 g(): evaluated
 g(): called
 f(): called
 
    
 
    데코레이터 평가 (Decorator Evaluation)
    
-
    클래스 내의 다양한 선언에 데코레이터를 적용하는 방법에는 잘 정의된 순서가 있습니다:
    
-
    매개 변수 Decorator, 메서드, 접근제어자 또는 속성 Decorator가 각 정적 멤버에 적용됩니다.
-Method, Accessor, PropertiesDecorator등에 의한 파라미터 Decorator는 각 정적 멤버에 대해 적용된다.
    
+
    클래스에서 다양한 선언에 데코레이터를 적용하는 방법은 다음과 같이 잘 정의되어 있습니다.
    
 
      
-
    1. 메서드, 접근제어자 또는 프로퍼티 데코레이터에 이어지는 매개변수 데코레이터는 각 인스턴스 멤버에 적용됩니다.
      2. 
-
    2. 메서드, 접근제어자 또는 프로퍼티 데코레이터에 이어지는 매개변수 데코레이터는 각 정적 멤버에 적용됩니다.
      3. 
-
    3. 매개변수 데코레이터는 생성자에 적용됩니다.
      4. 
-
    4. 클래스 데코레이터는 클래스에 적용됩니다.
      5. 
+
    5. 메서드, 접근자 또는 프로퍼티 데코레이터가 다음에 오는 매개 변수 데코레이터는 각 인스턴스 멤버에 적용됩니다.
      6. 
+
    6. 메서드, 접근자 또는 프로퍼티 데코레이터가 다음에 오는 매개 변수 데코레이터는 각 정적 멤버에 적용됩니다.
      7. 
+
    7. 매개 변수 데코레이터는 생성자에 적용됩니다.
      8. 
+
    8. 클래스 데코레이터는 클래스에 적용됩니다.
      9. 
 
    
 
    클래스 데코레이터 (Class Decorators)
    
-
    클래스 데코레이터는 클래스 선언 바로 직전에 선언됩니다.
    클래스 데코레이터는 클래스 정의를 관찰, 수정 또는 바꾸는 데 사용할 수 있는 클래스 생성자에 적용됩니다.
    클래스 데코레이터는 선언 파일이나 다른 ambient 컨텍스트(예: 선언 클래스)에서 사용할 수 없습니다.
    
-
    클래스 데코레이터에 대한 표현식은 런타임에 함수로 호출되며 데코레이팅 클래스의 생성자는 대상을 유일한 인수로 호출됩니다.
    
-
    클래스 데코레이터가 값을 반환하는 경우, 클래스 선언을 제공된 생성자 함수로 대체합니다.
    
+
    클래스 데코레이터는 클래스 선언 직전에 선언됩니다.
+클래스 데코레이터는 클래스 생성자에 적용되며 클래스 정의를 관찰, 수정 또는 교체하는 데 사용할 수 있습니다.
+클래스 데코레이터는 선언 파일이나 다른 주변 컨텍스트 (예: 선언 클래스)에서 사용할 수 없습니다.
    
+
    클래스 데코레이터의 표현식은 데코레이팅된 클래스의 생성자를 유일한 인수로 런타임에 함수로 호출됩니다.
    
+
    클래스 데코레이터가 값을 반환하면 클래스가 선언을 제공하는 생성자 함수로 바꿉니다.
    
 
    
-
    주의사항  새 생성자 함수를 반환하도록 선택해야하는 경우 원본 프로토타입을 유지하도록 관리해야합니다. 런타임에 데코레이터를 적용하는 로직은 이 작업을 수행하지 않습니다.
    
+
    참고  새 생성자 함수를 반환하도록 선택한 경우 원래 프로토타입을 유지 관리해야 합니다.
+런타임에 데코레이터를 적용하는 로직은 이 기능을 대신해주지 않습니다.
    
 
    
-
    다음은 Greeter 클래스에 적용된 클래스 데코레이터(@sealed)의 예제입니다:
    
+
    다음은Greeter 클래스에 적용된 클래스 데코레이터 (@sealed)의 예입니다.
    
 
    @sealed
 class Greeter {
     greeting: string;
@@ -826,13 +877,14 @@ 
    function sealed(constructor: Function) {
     Object.seal(constructor);
     Object.seal(constructor.prototype);
 }
 
    
-
    @sealed가 실행되면 생성자와 프로토타입 모두를 봉인합니다.
    다음은 생성자를 재정의하는 방법에 대한 예제입니다.
    
+
    @sealed가 실행되면 생성자와 프로토 타입을 모두 감쌉니다.
    
+
    생성자를 재정의하는 방법에 대한 예제는 다음과 같습니다.
    
 
    function classDecorator<T extends {new(...args:any[]):{}}>(constructor:T) {
     return class extends constructor {
         newProperty = "new property";
@@ -852,21 +904,23 @@ 
    console.log(new Greeter("world"));
 
    
 
    메서드 데코레이터 (Method Decorators)
    
-
    메서드 데코레이터는 메서드 선언 바로 직전에 선언됩니다.
    데코레이터는 메서드의 프로퍼티 Descriptor에 적용되며 메서드 정의를 관찰, 수정 또는 바꾸는 데 사용할 수 있습니다.
    메서드 데코레이터는 선언 파일, 오버로드 또는 기타 ambient 컨텍스트 (예: 선언 클래스)에서 사용할 수 없습니다.
    
-
    메서드 데코레이터의 표현식은 런타임에 다음 세 가지 인수와 함께 함수로 호출됩니다:
    
+
    메서드 데코레이터는 메서드 선언 직전에 선언됩니다.
+데코레이터는 메서드의 프로퍼티 설명자(Property Descriptor) 에 적용되며 메서드 정의를 관찰, 수정 또는 대체하는 데 사용할 수 있습니다.
+메서드 데코레이터는 선언 파일, 오버로드 또는 기타 주변 컨텍스트(예: 선언 클래스)에서 사용할 수 없습니다.
    
+
    메서드 데코레이터의 표현식은 런타임에 다음 세 개의 인수와 함께 함수로 호출됩니다:
    
 
      
-
    1. 정적 멤버에 대한 클래스의 생성자 함수거나 인스턴스 멤버에 대한 클래스의 프로토타입
      2. 
+
    2. 정적 멤버에 대한 클래스의 생성자 함수 또는 인스턴스 멤버에 대한 클래스의 프로토타입입니다.
      3. 
 
    3. 멤버의 이름
      4. 
-
    4. 멤버의 프로퍼티 Descriptor
      5. 
+
    5. 멤버의 프로퍼티 설명자
      6. 
 
    
 
    
-
    주의사항  스크립트 타겟이 ES5보다 작은 경우 프로퍼티 Descriptor는 undefined가 됩니다.
    
+
    참고  스크립트 대상이 'ES5'보다 낮은 경우 프로퍼티 설명자 는 'undefined'이 됩니다.
    
 
    
-
    메서드 데코레이터가 값을 반환하는 경우 해당 메서드에 대해 프로퍼티 Descriptor로 사용됩니다.
    
+
    메서드 데코레이터가 값을 반환하면, 메서드의 프로퍼티 설명자 로 사용됩니다.
    
 
    
-
    주의사항  스크립트 타겟이 ES5보다 작은 경우 반환 값은 무시됩니다.
    
+
    참고  스크립트 대상이 'ES5'보다 낮은 경우 반환 값은 무시됩니다.
    
 
    
-
    다음은 Greeter클래스의 메서드에 적용된 메서드 데코레이터 (@enumerable)의 예제입니다:
    
+
    다음은 Greeter 클래스의 메서드에 적용된 메서드 데코레이터 (@ enumerable)의 예입니다:
    
 
    class Greeter {
     greeting: string;
     constructor(message: string) {
@@ -879,34 +933,38 @@ 
    function enumerable(value: boolean) {
     return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
         descriptor.enumerable = value;
     };
 }
 
    
-
    @enumerable(false) 데코레이터는 데코레이터 팩토리입니다.
    @enumerable(false) 데코레이터가 호출되면 프로퍼티 Descriptor의 enumerable 프로퍼티를 수정합니다.
    
-
    접근제어자 데코레이터 (Accessor Decorators)
    
-
    접근제어자 데코레이터는 접근제어자 선언 바로 직전에 선언됩니다.
    접근제어자 데코레이터는 접근제어자에 대한 프로퍼티 Descriptor에 적용되며 접근제어자 정의를 관찰, 수정 또는 바꾸는 데 사용할 수 있습니다.
    데코레이터는 메서드의 프로퍼티 Descriptor에 적용되며 메서드 정의를 관찰, 수정 또는 바꾸는 데 사용할 수 있습니다.
    접근제어자 데코레이터는 선언 파일이나 다른 ambient 컨텍스트 (예: 선언 클래스)에서 사용할 수 없습니다.
    
+
    @enumerable(false)데코레이터는 데코레이터 팩토리입니다.
+@enumerable(false) 데코레이터가 호출되면 프로퍼티 설명자의 enumerable 프로퍼티를 수정합니다.
    
+
    접근자 데코레이터 (Accessor Decorators)
    
+
    접근자 데코레이터는 접근자 선언 바로 전에 선언됩니다.
+접근자 데코레이터는 접근자의 프로퍼티 설명자에 적용되며 접근자의 정의를 관찰, 수정 또는 교체하는 데 사용할 수 있습니다.
+접근자 데코레이터는 선언 파일이나 다른 주변 컨텍스트(예: 선언 클래스)에서 사용할 수 없습니다.
    
 
    
-
    주의사항  TypeScript는 단일 멤버에 대한 접근제어자 get과 set 모두 데코레이팅하는 것을 허용하지 않습니다.
-대신 멤버의 모든 데코레이터가 순서를 따라 첫 번째 접근제어자에게 적용되어야 합니다. 왜냐하면 데코레이터가 프로퍼티 Descriptor에 적용되기 때문입니다. 그리고 각 선언을 별도로 구분하지 않고 get과 set 접근제어자를 결합합니다.
    
+
    참고  TypeScript는 단일 멤버에 대해 get 및 set 접근자를 데코레이팅 할 수 없습니다.
+대신 멤버의 모든 데코레이터를 문서 순서대로 지정된 첫 번째 접근자에 적용해야 합니다.
+왜냐하면, 데코레이터는 각각의 선언이 아닌 get과 set 접근자를 결합한 프로퍼티 설명자에 적용되기 때문입니다.
    
 
    
-
    접근제어자 데코레이터 표현식은 런타임시 다음 세 가지 인수와 함께 함수로 호출됩니다:
    
+
    접근자 데코레이터의 표현 식은 런타임에 다음 세 가지 인수와 함께 함수로 호출됩니다:
    
 
      
-
    1. 정적 멤버에 대한 클래스의 생성자 함수나 인스턴스 멤버에 대한 클래스의 프로토타입이 있습니다
      2. 
+
    2. 정적 멤버에 대한 클래스의 생성자 함수 또는 인스턴스 멤버에 대한 클래스의 프로토타입
      3. 
 
    3. 멤버의 이름
      4. 
-
    4. 멤버에 프로퍼티 Descriptor
      5. 
+
    5. 멤버의 프로퍼티 설명자
      6. 
 
    
 
    
-
    주의사항  스크립트 타겟이 ES5보다 작은 경우 프로퍼티 Descriptor는 undefined가 됩니다.
    
+
    참고  스크립트 대상이 'ES5'보다 낮은 경우 프로퍼티 설명자는 undefined가 됩니다.
    
 
    
-
    접근제어자 데코레이터가 값을 반환하면 경우 해당 멤버에 대한 프로퍼티 Descriptor로 사용됩니다.
    
+
    접근자 데코레이터가 값을 반환하면 멤버의 프로퍼티 설명자로 사용됩니다.
    
 
    
-
    주의사항  스크립트 타겟이 ES5보다 작은 경우 반환 값은 무시됩니다.
    
+
    참고  스크립트 대상이 'ES5'보다 낮은 경우 반환 값은 무시됩니다.
    
 
    
-
    다음은 Point 클래스의 멤버에 적용된 접근제어자 데코레이터 (@configurable)의 예제입니다:
    
+
    다음은 Point 클래스의 멤버에 적용되는 접근자 데코레이터 (@configurable)의 예입니다:
    
 
    class Point {
     private _x: number;
     private _y: number;
@@ -930,18 +988,19 @@ 
    프로퍼티 데코레이터 (Property Decorators)
    
-
    프로퍼티 데코레이터는 프로퍼티 선언 바로 직전에 선언됩니다.
    프로퍼티 데코레이터는 선언 파일이나 기타 ambient 컨텍스트 (예: 선언 클래스)에서 사용할 수 없습니다.
    
-
    프로퍼티 데코레이터의 표현식은 런타임에 다음 두 가지 인수와 함께 함수로 호출됩니다:
    
+
    프로퍼티 데코레이터는 프로퍼티 선언 바로 전에 선언됩니다.
+프로퍼티 데코레이터는 선언 파일이나 다른 주변 컨텍스트(예: 선언 클래스)에서 사용할 수 없습니다.
    
+
    프로퍼티 데코레이터의 표현 식은 런타임에 다음 두 개의 인수와 함께 함수로 호출됩니다:
    
 
      
 
    1. 정적 멤버에 대한 클래스의 생성자 함수 또는 인스턴스 멤버에 대한 클래스의 프로토타입
      2. 
 
    2. 멤버의 이름
      3. 
 
    
 
    
-
    주의사항  프로퍼티 Descriptor는 프로퍼티 Descriptor가 TypeScript에서 초기화되는 방법으로 인해 프로퍼티 Descriptor에 대한 인수로 제공되지 않습니다.
-이는 현재 프로토타입의 멤버을 정의할 때 인스턴스 프로퍼티를 설명하는 메커니즘이 없고, 프로퍼티에 대한 이니셜라이저를 관찰하거나 수정할 방법이 없기 때문이다. 반환 값도 무시됩니다.
-따라서 프로퍼티 데코레이터는 특정 이름의 프로퍼티가 클래스에 대해 선언되는 것을 관찰하는 데만 사용할 수 있습니다.
    
+
    참고  TypeScript에서 프로퍼티 데코레이터가 초기화되는 방식으로 인해 프로퍼티 설명자가 프로퍼티 데코레이터에 대한 인수로 제공되지 않습니다.
+현재 프로토타입의 멤버를 정의할 때 인스턴스 프로퍼티를 설명하는 메커니즘이 없고 프로퍼티의 이니셜라이저를 관찰하거나 수정할 수 있는 방법이 없기 때문입니다. 반환 값도 무시됩니다.
+따라서 프로퍼티 데코레이터는 특정 이름의 프로퍼티가 클래스에 선언되었음을 관찰하는 데만 사용할 수 있습니다.
    
 
    
-
    다음 예와 같이 이 정보를 사용하여 프로퍼티에 대한 메타 데이터를 기록할 수 있습니다:
    
+
    이 정보를 사용하여 다음 예와 같이 프로퍼티에 대한 메타데이터를 기록할 수 있습니다:
    
 
    class Greeter {
     @format("Hello, %s")
     greeting: string;
@@ -955,7 +1014,7 @@ 
    import "reflect-metadata";
 
 const formatMetadataKey = Symbol("format");
@@ -968,23 +1027,28 @@ 
    return Reflect.getMetadata(formatMetadataKey, target, propertyKey);
 }
 
    
-
    @format("Hello, %s") 데코레이터는 데코레이터 팩토리입니다.
    @format("Hello, %s")이 호출되면 reflect-metadata 라이브러리의 Reflect.metadata 함수를 사용하여 프로퍼티에 대한 메타 데이터 항목을 추가합니다.
    getFormat를 호출하면 포맷에 대한 메타 데이터를 읽습니다.
    
+
    @format("Hello, %s") 데코레이터는 데코레이터 팩토리입니다.
+@format("Hello, %s")가 호출되면 reflect-metadata 라이브러리의 Reflect.metadata 함수를 사용하여 프로퍼티에 대한 메타데이터 항목을 추가합니다.
+getFormat이 호출되면 형식의 메타데이터 값을 읽습니다.
    
 
    
-
    참고  이 예제에는 reflect-metadata 라이브러리가 필요합니다. reflect-metadata 라이브러리에 대한 자세한 정보는 메타 데이터를 참조하세요.
    
+
    참고  이 예제에는 reflect-metadata 라이브러리가 필요합니다.
+reflect-metadata 라이브러리에 대한 자세한 내용은 메타데이터를 참조하십시오.
    
 
    
 
    매개변수 데코레이터 (Parameter Decorators)
    
-
    매개변수 데코레이터는 매개변수 선언 바로 직전에 선언됩니다.
    매개변수 데코레이터는 클래스 생성자 또는 메서드 선언의 함수에 적용됩니다.
    매개변수 데코레이터는 선언 파일, 오버로드 또는 기타 ambient 컨텍스트 (예: 선언 클래스)에서 사용할 수 없습니다.
    
-
    매개변수 데코레이터의 표현식은 런타임에 다음 세 가지 인수와 함께 함수로 호출됩니다:
    
+
    매개변수 데코레이터는 매개 변수 선언 직전에 선언됩니다.
+매개변수 데코레이터는 클래스 생성자 또는 메서드 선언의 함수에 적용됩니다.
+매개변수 데코레이터는 선언 파일, 오버로드 또는 다른 주변 컨텍스트(예: 선언 클래스)에서 사용할 수 없습니다.
    
+
    매개 변수 데코레이터의 표현식은 런타임시 다음 세 개의 인수와 함께 함수로 호출됩니다:
    
 
      
 
    1. 정적 멤버에 대한 클래스의 생성자 함수 또는 인스턴스 멤버에 대한 클래스의 프로토타입
      2. 
 
    2. 멤버의 이름
      3. 
-
    3. 함수의 매개 변수 목록내에 매개 변수의 서수(순서가 있는) 인덱스
      4. 
+
    4. 함수의 매개 변수 목록에 있는 매개 변수의 서수 색인(ordinal index)
      5. 
 
    
 
    
-
    주의사항  매개변수 데코레이터는 매개변수가 메서드에 선언되었음을 관찰하는 데만 사용할 수 있습니다.
    
+
    참고  매개변수 데코레이터는 매개변수가 메서드에서 선언되었을 때에만 관찰하는 데에 사용할 수 있습니다.
    
 
    
-
    매개변수 데코레이터의 반환 값은 무시됩니다.
    
-
    다음은 Greeter 클래스 멤버의 매개 변수에 적용된 매개 변수 데코레이터 (@required)의 예제입니다:
    
+
    메개변수 데코레이터의 반환 값은 무시됩니다.
    
+
    다음은 Greeter 클래스 멤버의 매개 변수에 적용되는 매개 변수 데코레이터 (@required)의 예입니다:
    
 
    class Greeter {
     greeting: string;
 
@@ -998,7 +1062,7 @@ 
    import "reflect-metadata";
 
 const requiredMetadataKey = Symbol("required");
@@ -1025,17 +1089,22 @@ 
    메타 데이터를 참조하세요.
    
+
    참고  이 예제에는 reflect-metadata 라이브러리가 필요합니다.
+reflect-metadata 라이브러리에 대한 자세한 내용은 [메타데이터] (#메타데이터-metadata)를 참조하십시오.
    
 
-
    메타 데이터
    
-
    일부 예제에서는 실험적인 메타 데이터 API에 대한 polyfill을 추가하는 reflect-metadata 라이브러리를 사용합니다.
    이 라이브러리는 아직 ECMAScript (JavaScript) 표준에 속하지 않습니다.
    하지만 데코레이터가 공식적으로 ECMAScript 표준의 일부로 채택되면 이러한 확장 기능이 채택되도록 제안될 것입니다.
    
-
    이 라이브러리는 npm을 통해 설치할 수 있습니다:
    
+
    메타데이터 (Metadata)
    
+
    일부 예제는 실험적 메타데이터 API에 대한 폴리필(polyfill)을 추가하는 reflect-metadata 라이브러리를 사용합니다.
+이 라이브러리는 아직 ECMAScript (JavaScript) 표준의 일부가 아닙니다.
+그러나 데코레이터가 공식적으로 ECMAScript 표준의 일부로 채택되면 이러한 확장을 채택하게 될 것입니다.
    
+
    npm을 통해 설치할 수 있습니다.
    
 
    npm i reflect-metadata --save
 
    
-
    TypeScript는 데코레이터가 있는 선언에 대한 특정 타입의 메타 데이터를 방출하기 위한 실험적인 지원을 포함하고 있습니다.
    이 실험적인 지원을 활성화하려면 커맨드 라인 또는 tsconfig.json에서  컴파일러 옵션 emitDecoratorMetadata을 설정해야 합니다:
    
-
    커맨드 라인:
    
+
    TypeScript에는 데코레이터가 있는 선언에 대해 특정 타입의 메타 데이터를 내보내는 실험적인 지원을 포함합니다.
+이 실험적인 지원을 가능하게 하려면, 명령행 또는tsconfig.json에서 emitDecoratorMetadata 컴파일러 옵션을 설정해야 합니다.
    
+
    명령줄:
    
 
    tsc --target ES5 --experimentalDecorators --emitDecoratorMetadata
 
    
 
    tsconfig.json:
    
@@ -1047,8 +1116,8 @@ 
    메타 데
     }
 }
 
    
-
    활성화가 될 때 reflect-metadata 라이브러리를 임포트 한 추가적인 design-time 타입 정보는 런타임에 노출됩니다.
    
-
    다음 예제에서는 이러한 기능이 실제로 작동하는 것을 볼 수 있습니다:
    
+
    활성화되면 reflect-metadata라이브러리를 가져오기만 하면 추가 디자인-타임 타입 정보가 런타임에 사용 가능합니다.
    
+
    다음 예제에서 이를 확인할 수 있습니다.
    
 
    import "reflect-metadata";
 
 class Point {
@@ -1076,12 +1145,12 @@ 
    메타 데
         if (!(value instanceof type)) {
             throw new TypeError("Invalid type.");
         }
-        set(value);
+        set.call(target, value);
     }
 }
 
    
-
    TypeScript 컴파일러는 @Reflect.metadata 데코레이터를 사용하여 design-time 타입 정보를 주입합니다.
    
-
    다음과 같은 TypeScript와 동일한 것으로 간주할 수 있습니다:
    
+
    TypeScript 컴파일러는 @Reflect.metadata 데코레이터를 사용하여 디자인-타임 타입 정보를 주입합니다.
+다음 TypeScript와 동일하다고 생각할 수 있습니다.
    
 
    class Line {
     private _p0: Point;
     private _p1: Point;
@@ -1098,7 +1167,7 @@ 
    메타 데
 }
 
    
 
    
-
    참고  데코레이터 메타 데이터는 시험적인 기능이며 향후 공개에서 중요한 변경 사항을 도입할 수 있습니다.
    
+
    참고  데코레이터 메타 데이터는 실험적인 기능으로 향후 릴리스에서 주요 변경 사항이 있을 수 있습니다.
    
 
    
 
                                 
@@ -1143,7 +1212,7 @@ 
    No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"데코레이터","level":"3.19","depth":1,"next":{"title":"믹스인","level":"3.20","depth":1,"path":"pages/Mixins.md","ref":"pages/Mixins.md","articles":[]},"previous":{"title":"JSX","level":"3.18","depth":1,"path":"pages/JSX.md","ref":"pages/JSX.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Decorators.md","mtime":"2019-06-14T05:32:52.237Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"데코레이터","level":"3.19","depth":1,"next":{"title":"믹스인","level":"3.20","depth":1,"path":"pages/Mixins.md","ref":"pages/Mixins.md","articles":[]},"previous":{"title":"JSX","level":"3.18","depth":1,"path":"pages/JSX.md","ref":"pages/JSX.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Decorators.md","mtime":"2020-04-22T15:29:36.173Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Enums.html b/pages/Enums.html
index e259cfdd..3974d593 100644
--- a/pages/Enums.html
+++ b/pages/Enums.html
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
    • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
  • 
+        
  • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
    • 
+    
+        
  • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
  • 릴리즈 노트
    • 
+        
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
    • 
+    
+
+    
 
     
  • 
 
@@ -712,9 +758,12 @@ 
    
                                 
    
                                 
                                 
    열거형 (Enums)
    
-
    열거형을 사용하면 이름이 있는 상수들을 정의할 수 있습니다.
    열거형의 사용은 문서의 의도나 명확한 사례들을 쉽게 만들 수 있습니다.
    TypeScript 는 숫자 및 문자열 기반 열거형을 모두 제공합니다.
    
+
    열거형으로 이름이 있는 상수들의 집합을 정의할 수 있습니다.
+열거형을 사용하면 의도를 문서화 하거나 구분되는 사례 집합을 더 쉽게 만들수 있습니다.
+TypeScript는 숫자와 문자열-기반 열거형을 제공합니다.
    
 
    숫자 열거형 (Numeric enums)
    
-
    먼저 숫자 열거형으로 시작합니다.
    다른 언어에서 열거형을 접해봤다면 더 익숙 할 것입니다.
    열거형은 enum 키워드를 사용하여 정의할 수 있습니다.
    
+
    다른 언어를 배워 보신 분들이라면 친숙하게 느끼실 수 있는 숫자 열거형에 대해서 먼저 배워보겠습니다.
+열거형은 enum 키워드를 사용해 정의할 수 있습니다.
    
 
    enum Direction {
     Up = 1,
     Down,
@@ -722,8 +771,10 @@ 
    숫자
     Right,
 }
 
    
-
    위에서 Up 는 1 로 초기화된 숫자 열거형입니다.
    아래에 이어서 등장하는 멤버들은 자동으로 증가합니다.
    즉, Direction.Up 은 1, Down 은 2, Left 는 3, Right 는 4 입니다.
    
-
    원한다면 초기화를 완전히 없앨 수도 있습니다.
    
+
    위 코드에서 Up이 1 로 초기화된 숫자 열거형을 선언했습니다.
+그 지점부터 뒤따르는 멤버들은 자동으로-증가된 값을 갖습니다.
+즉 Direction.Up 은 1,  Down 은 2, Left 는 3, Right 은 4 을 값으로 가집니다.
    
+
    원한다면, 전부 초기화 하지 않을 수도 있습니다:
    
 
    enum Direction {
     Up,
     Down,
@@ -731,8 +782,9 @@ 
    숫자
     Right,
 }
 
    
-
    여기에서는 Up 은 0 이며, Down 은 1 이 됩니다.
    이 자동 증가 동작은 멤버의 값 자체에 신경 쓰지 않고 각 열거형이 동일한 열거형의 다른 값과 구별되는 경우에 유용합니다.
    
-
    열거형을 사용하는 것은 간단합니다: 열거형 자체의 속성으로 모든 멤버에 엑섹스하고, 열거형의 이름을 사용하여 타입을 선언합니다.
    
+
    위 경우 Up 값은 0,  Down 은 1 이 됩니다.
+자동-증가하는 기능은 멤버 값 자체에는 신경 쓰지 않지만, 각 값이 같은 열거형의 다른 값과 구별돼야 하는 경우에 유용합니다.
    
+
    열거형을 사용하는 것은 간단합니다: 그냥 열거형 자체에서 프로퍼티로 모든 멤버에 접근하며, 열거형의 이름을 사용해 타입을 선언합니다.
    
 
    enum Response {
     No = 0,
     Yes = 1,
@@ -744,14 +796,17 @@ 
    숫자
 
 respond("Princess Caroline", Response.Yes)
 
    
-
    숫자 열거형은 계산된, 상수 멤버 (computed and constant members)에 혼합될 수 있습니다.
    단편적으로 초기화가 없는 열거형은 상수 또는 다른 상수 열거형의 멤버로 초기화된 숫자 열거형을 따라야할 필요가 있습니다.
    즉, 다음은 허용되지 않습니다:
    
+
    숫자 열거형은 계산된 멤버와 상수 멤버 (아래 참조)를 섞어서 사용할 수 있습니다.
+간단히 말해, 초기화되지 않은 열거형이 먼저 나오거나, 숫자 상수 혹은 다른 상수 열거형 멤버와 함께 초기화된 숫자 열거형 이후에 와야 합니다.
+즉 아래 방식은 허용되지 않습니다:
    
 
    enum E {
     A = getSomeValue(),
-    B, // 오류 ! A 는 상수로 초기화되지 않았으므로 B에는 초기화가 필요합니다.
+    B, // 오류! 앞에 나온 A가 계산된 멤버이므로 초기화가 필요합니다.
 }
 
    
-
    문자 열거형 (String enums)
    
-
    문자 열거형은 비슷한 개념이지만 아래에 설명 된 것과 같이 약간의 미묘한 실행시 차이 (runtime differences)가 있습니다.
    문자 열거형에서 각 멤버는 문자열 리터럴 또는 다른 문자 열거형 멤버로 상수초기화되어야 합니다.
    
+
    문자열 열거형 (String enums)
    
+
    문자열 열거형은 유사한 개념이지만 아래 설명된 것과 같이 런타임에서 열거형의 동작이 약간 다릅니다.
+문자열 열거형에서 각 멤버들은 문자열 리터럴 또는 다른 문자열 열거형의 멤버로 상수 초기화 해야 합니다.
    
 
    enum Direction {
     Up = "UP",
     Down = "DOWN",
@@ -759,25 +814,28 @@ 
    문자
     Right = "RIGHT",
 }
 
    
-
    문자 열거형은 자동 증가 동작을 하지 않지만 문자 열거형은 "직렬화(serialize)"하는 이점이 있습니다.
    즉, 디버깅 중이며 숫자 열거형의 런타임 값을 읽어야하는 경우 이 값은 종종 불투명합니다 - 즉, 자체적으로 유용한 의미를 전달하지는 않습니다.(역 매핑 (enums-at-runtime)이 도움이 될것입니다)
    문자 열거형을 사용하면 열거형 멤버 자체의 이름과 독립적으로 코드가 실행될 때 의미있고 읽기 쉬운 값을 제공합니다.
    
-
    별종 열거형 (Heterogeneous enums)
    
-
    엄밀히 말하자면 열거형은 문자열과 숫자 멤버와 섞일 수는 있지만 그렇게 할 이유는 없습니다.
    
+
    문자열 열거형은 숫자 열거형처럼 자동-증가하는 기능은 없지만, "직렬화"를 잘한다는 이점이 있습니다.
+다시 말해서 만약 당신이 숫자 열거형을 이용해서 디버깅하고 있고 그 값을 읽어야 한다면, 종종 그 값이 불확실한 경우가 있습니다 - 숫자만으로는 이것이 어떤 의미인지 유의미한 정보를 제공해주지 않기 때문입니다. (역 매핑 을 이용하면 도움이 될지라도 말입니다), 반면 문자열 열거형을 이용하면 코드를 실행할 때, 열거형 멤버에 지정된 이름과는 무관하게 유의미하고 읽기 좋은 값을 이용하여 실행할 수 있습니다.
    
+
    이종 열거형 (Heterogeneous enums)
    
+
    기술적으로 열거형은 숫자와 문자를 섞어서 사용할 수 있지만 굳이 그렇게 할 이유는 없습니다.
    
 
    enum BooleanLikeHeterogeneousEnum {
     No = 0,
     Yes = "YES",
 }
 
    
-
    JavaScript의 런타임 동작을 실제로 사용하려고 하지 않는 한, 이렇게 하지 않는 것이 좋습니다. 
    
-
    계산된 상수 멤버 (Computed and constant members)
    
-
    각 열거형 멤버에는 constant 또는 computed 중 하나일 수 있는 값이 있습니다.
    열거형 멤버는 다음과 같은 경우 상수로 간주됩니다:
    
+
    확실하게 JavaScript 런타임에서 장점을 취하려는 것이 아니라면, 이렇게 사용하지 않는 것을 권장합니다.
    
+
    계산된 멤버와 상수 멤버 (Computed and constant members)
    
+
    각 열거형의 멤버는 상수이거나 계산된 값일 수 있습니다.
+열거형의 멤버는 아래의 경우 상수로 간주합니다:
    
 
      
-
    • 열거형의 첫 번째 멤버이며 초기화가 없으면 값이 0 으로 지정됩니다:
      
-
      // E.X 는 상수입니다:
+
    • 열거형의 첫 번째 데이터이며 초기화 값이 없는 경우, 0으로 값이 할당됩니다.
      
+
      // E.X는 상수입니다:
 enum E { X }
 
      
 
      • 
-
    • 초기화가 없고 앞의 열거형 멤버가 숫자 인 상수입니다.
      이 경우 이후 나오는 열거형 멤버의 값은 이전 열거형 멤버의 값에 1을 더한 값이 됩니다.
      
-
      // E1 및 E2의 모든 열거형 멤버는 상수입니다.
+
    • 초기화 값이 없으며 숫자 상수로 초기화된 열거형 멤버 뒤에 따라 나오는 경우.
+앞에 나온 상수 값에 1씩 증가한 값을 상수로 갖습니다.
      
+
      // 'E1' 과 'E2' 의 모든 열거형 멤버는 상수입니다.
 
 enum E1 { X, Y, Z }
 
@@ -786,18 +844,20 @@ 
      enum FileAccess {
     // 상수 멤버
     None,
@@ -808,16 +868,17 @@ 
      G = "123".length
 }
 
      
-
      통합 열거형 및 열거형 멤버 타입 (Union enums and enum member types)
      
-
      계산되지 않은 상수 열거형 멤버의 특수 하위 집합이 있습니다: 리터럴 열거형 멤버입니다.
      리터럴 열거형 멤버는 초기화된 값이 없거나 다음 값으로 초기화 된 값이 있는 상수 열거형 멤버입니다.
      
+
      유니언 열거형과 열거형 멤버 타입 (Union enums and enum member types)
      
+
      계산되지 않는 상수 열거 멤버의 특수한 부분 집합이 있습니다: 리터럴 열거형 멤버
+리터럴 열거형 멤버는 초기화 값이 존재하지 않거나, 아래 값들로 초기화되는 멤버입니다.
      
 
        
-
      • 문자열 리터럴 (예: "foo", "bar", "baz")
        • 
-
      • 숫자 리터럴 (예: 1, 100)
        • 
-
      • 숫자 리터럴에 적용되는 단항 마이너스 (예: -1, -100)
        • 
+
      • 문자 리터럴 (예시. "foo", "bar, "baz")
        • 
+
      • 숫자 리터럴 (예시. 1, 100)
        • 
+
      • 숫자 리터럴에 단항 연산자 - 가 적용된 경우 (e.g. -1, -100)
        • 
 
      
-
      열거형의 모든 멤버가 리터럴 열거형 값을 가질 때 일부 특수한 의미가 있습니다.
      
-
      첫번째는 열거형 멤버도 타입이 된다는 것입니다.
-예를 들어 특정 멤버는 열거형 멤버의 값만 가질 수 있습니다.
      
+
      열거형의 모든 멤버가 리터럴 열거형 값을 가지면 특별한 의미로 쓰이게 됩니다.
      
+
      첫째로 열거형 멤버를 타입처럼 사용할 수 있습니다!
+예를 들어 특정 멤버는 오직 열거형 멤버의 값만 가지게 할 수 있습니다.
      
 
      enum ShapeKind {
     Circle,
     Square,
@@ -834,12 +895,14 @@ 
      let c: Circle = {
-    kind: ShapeKind.Square,
-    //    ~~~~~~~~~~~~~~~~ 오류!
+    kind: ShapeKind.Square, // 오류! 'ShapeKind.Circle' 타입에 'ShapeKind.Square' 타입을 할당할 수 없습니다.
     radius: 100,
 }
 
      
-
      또 다른 변화는 열거 타입 자체가 각 열거형 멤버의 합집합(union) 이 된다는 것입니다.
      결합 타입 (union types)에 대해 아직 배우지 않았지만, 알아 두어야 할 것은 조합 열거형을 사용하는 타입 시스템이 열거형 자체에 존재하는 정확한 값들을 알고있다는 사실을 활용할 수 있다는 것입니다.
      이 때문에 TypeScript는 값을 잘못 비교하는 바보같은 버그를 잡을 수 있습니다.
      
+
      또 다른 점은 열거형 타입 자체가 효율적으로 각각의 열거형 멤버의 유니언이 된다는 점입니다.
+아직 유니언 타입에 대해서 배우진 않았지만, 유니언 타입 열거형을 사용하면 타입 시스템이 열거형 자체에 존재하는 정확한 값의 집합을 알고 있다는 사실을 활용할 수 있다는 점만 알아두면 됩니다.
+이 때문에 TypeScript는 값을 잘못 비교하는 어리석은 버그를 잡을 수 있습니다.
+예를 들어:
      
 
      enum E {
     Foo,
     Bar,
@@ -848,36 +911,60 @@ 
      function f(x: E) {
     if (x !== E.Foo || x !== E.Bar) {
         //             ~~~~~~~~~~~
-        // 오류! 연산자 '!==' 는 'E.Foo' 및 'E.Bar' 타입에 적용할 수 없습니다.
+        // 에러! E 타입은 Foo, Bar 둘 중 하나이기 때문에 이 조건은 항상 true를 반환합니다.
     }
 }
 
      
-
      이 예제에서, 먼저 x 가 E.Foo 가 가 아닌지 검사했습니다.
      이 검사를 성공하면 || 가 실행되지 않고 'if' 의 내부가 실행됩니다.
      하지만 검사를 성공하지 못하면 x 는 오직 E.Foo 만 될 수 있습니다. 따라서 E.Bar 와 동일한 지 확인하는 것은 의미가 없습니다.
      
-
      런타임시의 열거형 (Enums at runtime)
      
-
      열거형은 런타임에 존재하는 실제 객체입니다.
      
-
      예를 들어 다음 열거형을 보면,
      
+
      이 예제에서 우리는 x 가 E.Foo 가 아닌지 확인합니다.
+만약 이 조건이 true 라면, || 조건은 더는 체크할 필요가 없으므로 if 아래의 body가 실행될 것입니다.
+그러나 만약 이 조건이 통과되지 않는다면, x 는 반드시 E.Foo 이기 때문에, x가 E.Bar 가 아닌지 묻는 조건과 비교하는 것은 적절하지 않습니다.
      
+
      런타임에서 열거형 (Enums at runtime)
      
+
      열거형은 런타임에 존재하는 실제 객체입니다.
+예를 들어 아래와 같은 열거형은
      
 
      enum E {
     X, Y, Z
 }
 
      
-
      실제로 함수에 전달 될 수 있습니다.
      
+
      실제로 아래와 같이 함수로 전달될 수 있습니다.
      
 
      function f(obj: { X: number }) {
     return obj.X;
 }
 
-// 작동합니다. 왜냐하면 `E` 는 숫자인 `X` 라는 속성을 가지고있기 떄문입니다.
+// E가 X라는 숫자 프로퍼티를 가지고 있기 때문에 동작하는 코드입니다.
 f(E);
 
      
+
      컴파일 시점에서 열거형 (Enums at compile time)
      
+
      열거형이 런타임에 존재하는 실제 객체라고 할지라도, keyof 키워드는 일반적인 객체에서 기대하는 동작과 다르게 동작합니다. 대신, keyof typeof 를 사용하면 모든 열거형의 키를 문자열로 나타내는 타입을 가져옵니다.
      
+
      enum LogLevel {
+    ERROR, WARN, INFO, DEBUG
+}
+
+/**
+ * 이것은 아래와 동일합니다. :
+ * type LogLevelStrings = 'ERROR' | 'WARN' | 'INFO' | 'DEBUG';
+ */
+type LogLevelStrings = keyof typeof LogLevel;
+
+function printImportant(key: LogLevelStrings, message: string) {
+    const num = LogLevel[key];
+    if (num <= LogLevel.WARN) {
+       console.log('Log level key is: ', key);
+       console.log('Log level value is: ', num);
+       console.log('Log level message is: ', message);
+    }
+}
+printImportant('ERROR', 'This is a message');
+
      
 
      역 매핑 (Reverse mappings)
      
-
      멤버에 대한 속성 이름이 있는 객체를 만드는 것 외에도 숫자 열거형 멤버는 열거형 값에서 열거형의 이름으로 역 매핑(reverse mapping) 을 받습니다.
      
-
      예를 들어, 다음 예제에서:
      
+
      숫자 열거형 멤버는 멤버의 프로퍼티 이름을 가진 객체를 생성하는 것 외에도 열거형 값에서 열거형 이름으로 역 매핑 을 받습니다.
+예를 들어 아래의 예제에서:
      
 
      enum Enum {
     A
 }
 let a = Enum.A;
 let nameOfA = Enum[a]; // "A"
 
      
-
      TypeScript는 이것을 다음 JavaScript로 컴파일합니다.
      
+
      TypeScript는 아래와 같은 JavaScript 코드로 컴파일할 겁니다.
      
 
      var Enum;
 (function (Enum) {
     Enum[Enum["A"] = 0] = "A";
@@ -885,16 +972,22 @@ 
      역 매핑 (R
 var a = Enum.A;
 var nameOfA = Enum[a]; // "A"
 
      
-
      이 생성된 코드에서 열거형은 전방향(forward) (name -> value) 매핑과 역방향(reverse) (value -> name) 매핑을 모두 저장하는 객체로 컴파일됩니다.
      다른 열거형 멤버에 대한 참조는 항상 속성 접근으로 방출되며 결고 인라인(inline)되지 않습니다.
      
-
      문자열 열거형 멤버는 역매핑을 생성하지 않습니다.
      
+
      이렇게 생성된 코드에서, 열거형은 정방향 (name -> value) 매핑과 역방향 (value -> name) 매핑 두 정보를 모두 저장하는 객체로 컴파일됩니다.
+다른 열거형 멤버 참조는 항상 프로퍼티 접근으로 노출되며 인라인되지 않습니다.
      
+
      문자열 열거형은 역 매핑을 생성하지 않는다 는 것을 명심하시길 바랍니다.
      
 
      const 열거형 (const enums)
      
-
      대부분의 경우 열거형은 완벽하게 유효현 방법입니다.
      하지만 때떄로 요구사항이 더 엄격합니다.
      열거형의 값에 접근할 때 여부느이 생성된 코드와 추가적인 우회 비용을 피하려면 const 열거형을 사용 할 수 있습니다.
      const 열거형은 열거형에 const 지시자를 사용하여 정의합니다.
      
+
      대부분의 경우, 열거형은 완벽하게 유효한 해결책입니다.
+하지만 종종 열거형의 요구사항이 좀 더 엄격해 집니다.
+열거형 값에 접근할 때, 추가로 생성된 코드 및 추가적인 간접 참조에 대한 비용을 피하기 위해 const 열거형을 사용할 수 있습니다.
+const 열거형은 const 지정자를 열거형에 붙여 정의합니다.
      
 
      const enum Enum {
     A = 1,
     B = A * 2
 }
 
      
-
      const 열거형은 상수 열거형 표현식만 사용할 수 있으며 일반 열거형과 달리 컴파일하는 동안 완전히 제거됩니다.
      const 열거형 멤버는 사용하는 사이트에서 인라인(inline)됩니다.
      const 열거형은 계산된 멤버를 가질수 없기 때문에 가능합니다.
      
+
      const 열거형은 상수 열거형 표현식만 사용될 수 있으며 일반적인 열거형과 달리 컴파일 과정에서 완전히 제거됩니다.
+const 열거형은 사용하는 공간에 인라인됩니다.
+이러한 동작은 const 열거형이 계산된 멤버를 가지고 있지 않기 때문에 가능합니다.
      
 
      const enum Directions {
     Up,
     Down,
@@ -904,17 +997,19 @@ 
      const 열&
 
 let directions = [Directions.Up, Directions.Down, Directions.Left, Directions.Right]
 
      
-
      코드는 다음과 같이 컴파일 됩니다.
      
+
      위 코드는 아래와 같이 컴파일됩니다.
      
 
      var directions = [0 /* Up */, 1 /* Down */, 2 /* Left */, 3 /* Right */];
 
      
-
      앰비언트 열거형 (Ambient enums)
      
+
      Ambient 열거형 (Ambient enums)
      
+
      Ambient 열거형은 이미 존재하는 열거형 타입의 모습을 묘사하기 위해 사용됩니다.
      
 
      declare enum Enum {
     A = 1,
     B,
     C = 2
 }
 
      
-
      앰비언트 열거형과 비앰비언트 열거형의 중요한 차이점 중 하나는 일반 열거형에서 초기화가 없는 멤버는 이전 열거형 멤버가 상수로 간주된다는 것입니다.
      반대로, 초기화가 없는 앰비언트 (그리고 비상수(non-const)) 열거형 멤버는 항상 계산된 것으로 간주됩니다.
      
+
      ambient 열거형과 비-ambient 열거형의 가장 큰 차이점은, 일반적인 열거형에서 초기화되지 않은 멤버가 상수로 간주하는 멤버 뒤에 있다면, 이 멤버도 상수로 간주할 것입니다.
+반면 (const가 아닌) ambient 열거형에서 초기화되지 않은 멤버는 항상 계산된 멤버로 간주합니다.
      
 
                                 
                                 
    
@@ -958,7 +1053,7 @@ 
    No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"열거형","level":"3.7","depth":1,"next":{"title":"타입 추론","level":"3.8","depth":1,"path":"pages/Type Inference.md","ref":"pages/Type Inference.md","articles":[]},"previous":{"title":"제네릭","level":"3.6","depth":1,"path":"pages/Generics.md","ref":"pages/Generics.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Enums.md","mtime":"2019-06-14T05:32:52.238Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"열거형","level":"3.7","depth":1,"next":{"title":"타입 추론","level":"3.8","depth":1,"path":"pages/Type Inference.md","ref":"pages/Type Inference.md","articles":[]},"previous":{"title":"제네릭","level":"3.6","depth":1,"path":"pages/Generics.md","ref":"pages/Generics.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Enums.md","mtime":"2020-04-22T15:29:36.173Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Functions.html b/pages/Functions.html
index f1ad4063..04184790 100644
--- a/pages/Functions.html
+++ b/pages/Functions.html
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
    • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
  • 
+        
  • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
    • 
+    
+        
  • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
  • 릴리즈 노트
    • 
+        
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
    • 
+    
+
+    
 
     
  • 
 
@@ -712,72 +758,89 @@ 
    
                                 
    
                                 
                                 
    소개 (Introduction)
    
-
    함수는 JavaScript의 모든 애플리케이션을 구성하는 기본 요소입니다.
    클래스는 추상화 계층, 클래스, 정보 은닉 및 모듈을 구축하는 방법입니다.
    TypeScript에서는 클래스와 네임 스페이스 그리고 모듈이 있지만 함수는 그럼에도 불구하고 작업 방법을 설명하는 데 중요한 역할을 합니다.
    또한 TypeScript는 표준 JavaScript 기능에 몇가지 새로운 기능을 추가하여 작업을 더 쉽게 해 줍니다.
    
-
    함수 (Functions)
    
-
    JavaScript와 마찬가지로 TypeScript 함수는 기명 함수 또는 익명 함수로 만들 수 있습니다.
    이를 통해 API의 함수 목록을 작성하든 다른 함수에 전달할 일회성 함수이든 애플리케이션에 가장 적합한 접근 방법을 선택할 수 있습니다.
    
-
    이 두가지 접근 방식이 JavaScript에서 어떻게 보이는지 빠르게 요약하면:
    
-
    // 기명 함수
-function add(x, y) {
-    return x + y;
+
    함수는 JavaScript로 된 모든 애플리케이션에서의 기본적인 구성 요소입니다.
+JavaScript 함수는 추상화 계층을 구축하거나 클래스 모방, 정보 은닉, 모듈에 대한 방법을 제공합니다.
+TypeScript에는 클래스, 네임스페이스, 모듈이 있지만, 함수는 여전히 이 일을 어떻게 할 것인지를 설명하는 데 있어 핵심 역할을 수행합니다.
+TypeScript에서는 표준 JavaScript 함수가 작업을 수월하게 하도록 몇 가지 새로운 기능을 추가합니다.
    
+
    함수 (Function)
    
+
    TypeScript 함수는 JavaScript와 마찬가지로 기명 함수(named function)과 익명 함수(anonymous function)로 만들 수 있습니다.
+이를 통해 API에서 함수 목록을 작성하든 일회성 함수를 써서 다른 함수로 전달하든 애플리케이션에 가장 적합한 방법을 선택할 수 있습니다.
    
+
    JavaScript에서의 이 두 가지 방법에 대한 예시를 빠르게 다시 보겠습니다:
    
+
    // 기명 함수
+fucntion add(x, y) {
+  return x + y;
 }
 
 // 익명 함수
-let myAdd = function(x, y) { return x + y; };
+let myAdd = function(x, y) { return x + y };
 
    
-
    JavaScript에서와 마찬가지로 함수는 함수 본문 외부의 변수를 참조할 수 있습니다.
    그렇게 할 때 이러한 변수들을 capture라고 말합니다.
    이 기법의 사용 방법과 사용할 때의 절충 사항을 이해하는 것은 이번 장의 범위를 벗어나지만
    캡처의 메커니즘이 JavaScript와 TypeScript에 얼마나 중요한 부분인지 확실히 이해해야 합니다.
    
-
    let z = 100;
+
    JavaScript에서처럼, 함수는 함수 외부의 변수를 참조할 수 있습니다.
+이런 경우를, 변수를 캡처(capture) 한다고 합니다.
+이것이 어떻게 작동하는지 (그리고 이 기술을 사용할 때의 장단점)를 이해하는 것은 이 본문의 주제를 벗어나는 것이지만, 이 메커니즘이 어떻게 작동하는지에 대한 확실한 이해는 JavaScript 및 TypeScript를 사용하는 데 있어 중요합니다.
    
+
    let z = 100;
 
 function addToZ(x, y) {
-    return x + y + z;
+  return x + y + z;
 }
 
    
-
    함수의 타입 (Function Types)
    
-
    함수 작성하기 (Typing the function)
    
-
    앞에서 살펴본 간단한 예제에 타입을 추가해보겠습니다.
    
+
    함수 타입 (Function Types)
    
+
    함수의 타이핑 (Typing the function)
    
+
    이전에 사용했던 예시에 타입을 더해보겠습니다.
    
 
    function add(x: number, y: number): number {
     return x + y;
 }
 
-let myAdd = function(x: number, y: number): number { return x + y; };
+let myAdd = function(x: number, y: number): number { return x + y };
 
    
-
    각 매개변수에 타입을 추가 한 다음 함수 자체에 타입을 추가하여 반환 타입을 추가할 수 있습니다.
    TypeScript는 리턴문를 보고 반환 타입을 파악할 수 있기 때문에 대부분 선택적으로 반환 타입을 생략할 수 있습니다.
    
+
    각 파라미터와 함수 자신의 반환될 타입을 정해줄 수 있습니다.
+TypeScript는 반환 문을 보고 반환 타입을 파악할 수 있으므로 반환 타입을 생략할 수 있습니다.
    
 
    함수 타입 작성하기 (Writing the function type)
    
-
    이제 함수를 작성했으므로 함수 타입의 각 부분을 살펴보면서 함수의 전체 타입을 작성해보겠습니다.
    
+
    함수에 타입을 붙였으니, 이제 함수 타입들을 살펴보고 함수의 전체 타입을 작성해 봅시다.
    
 
    let myAdd: (x: number, y: number) => number =
     function(x: number, y: number): number { return x + y; };
 
    
-
    함수의 타입은 두개의 파트로 나뉩니다: 인수의 타입과 반환 타입.
    전체 함수 타입을 작성할 때 두 파트가 모두 필요합니다.
    매개변수 타입과 같이 매개변수 목록을 기록하여 각 매개변수에 이름과 타입을 지정합니다.
    이 이름은 가독성을 돕기 위한 것입니다.
    
-
    위의 코드를 다음과 같이 작성할 수 있습니다:
    
+
    함수의 타입은 매개변수의 타입과 반환 타입이 있습니다.
+전체 함수 타입을 작성하고자 한다면 이 두 가지 타입이 필요합니다.
+매개변수 목록처럼 각 매개변수에 이름과 타입 타입을 작성해 줍시다.
+작성하는 이름은 가독성을 위한 것입니다.
+위의 코드 대신 이렇게 쓸 수도 있습니다:
    
 
    let myAdd: (baseValue: number, increment: number) => number =
     function(x: number, y: number): number { return x + y; };
 
    
-
    매개변수 타입이 정렬되어 있는 한 함수의 타입에 매개변수를 제공하는 이름에 관계 없이 매개변수 타입이 유효한 타입으로 간주됩니다.
    
-
    두 번째 파트는 반환 타입입니다.
    매개변수와 반환 타입 사이에 굵은 화살표(=>)를 사용하여 반환 타입을 명확하게 합니다.
    앞서 언급한 것처럼 이것은 함수 타입의 필수적인 부분이므로 함수가 값을 반환하지 않는 경우에는 반환 값을 남겨 두지 않고 void를 사용합니다.
    
-
    주의사항, 매개변수와 반환 타입만 함수 타입을 구성합니다.
    캡처된 변수는 타입에 반영되지 않습니다.
    실제로 캡처된 변수는 함수의 "숨겨진 상태"의 일부이며 해당 API를 구성하지 않습니다.
    
-
    타입 추론 (Inferring the types)
    
-
    예를 들어 TypeScript 컴파일러는 한쪽에는 타입이 있지만 다른 한쪽에 타입이 없는 경우 그 타입을 이해할 수 없다는 것을 알게 됩니다:
    
-
    // myAdd는 완벽하게 함수 타입을 가지고 있습니다.
+
    매개변수의 타입들이 올바르게 나열되어 있다면 함수 타입에 이름을 붙이더라도 유효한 타입으로 간주합니다.
    
+
    두 번째로 반환 타입입니다.
+매개변수 타입들과 반환 타입 사이에 '화살표 표기'( => )를 써서 반환 타입을 분명히 할 수 있습니다.
+이전에 언급했듯이, 함수 표기에 필요한 부분입니다, 그래서 만약 함수가 값을 반환하지 않는다면 비워두는 대신 void를 써서 표시합니다.
    
+
    참고로, 매개변수 타입과 반환 타입만이 함수 타입을 구성합니다.
+캡처된 변수는 타입에 반영되지 않습니다.
+사실상 캡처된 변수는 함수의 "숨겨진 상태"의 일부이고 API를 구성하지 않습니다.
    
+
    타입의 추론 (Inferring the types)
    
+
    아래 예시를 직접 입력해보세요. TypeScript 컴파일러가 방정식의 한쪽에만 타입이 있더라도 타입을 알아낼 수 있다는 것을 알아채셨나요?
    
+
    // myAdd는 전체 함수 타입을 가집니다
 let myAdd = function(x: number, y: number): number { return  x + y; };
 
-// 매개변수 'x'와 'y'에는 number 타입이 있습니다.
+// 매개변수 x 와 y는 number 타입을 가집니다
 let myAdd: (baseValue: number, increment: number) => number =
     function(x, y) { return x + y; };
 
    
-
    이것을 타입 추론의 한 종류인 "상황적 타이핑(Contextual Typing)"이라고 합니다.
-이를 통해 프로그램을 계속 유지하는 데 드는 노력을 줄일 수 있습니다.
    
-
    선택적 매개변수와 기본 매개변수 (Optional and Default Parameters)
    
-
    TypeScript에서는 모든 매개변수가 함수에 필요하다고 가정합니다.
    null 또는 undefined가 주어질 수 없다는 것을 의미하는 것이 아니라 함수가 호출될 때 컴파일러가 각 매개변수에 값을 제공했는지 확인한다는 것입니다.
    또한 컴파일러는 이러한 매개변수들이 함수로 전달되는 유일한 매개변수라고 가정합니다.
    간단히 말해서 함수에 주어진 인수의 수는 그 함수에서 기대하는 매개변수의 수와 일치해야 합니다.
    
+
    이러한 타입 추론 형태를 "contextual typing" 이라 부릅니다.
+이를 통해 여러분의 프로그램에서 타입을 유지하기 위한 노력을 줄일 수 있습니다.
    
+
    선택적 매개변수와 기본 매개변수 (Optional and Default Parameter)
    
+
    TypeScript에서는 모든 매개변수가 함수에 필요하다고 가정합니다.
+이것이 null 이나 undefined를 줄 수 없다는 걸 의미하는 것은 아닙니다. 대신 함수가 호출될 때, 컴파일러는 각 매개변수에 대해 사용자가 값을 제공했는지를 검사합니다.
+또한, 컴파일러는 매개변수들이 함수로 전달될 유일한 매개변수라고 가정합니다. 요약하자면, 함수에 주어진 인자의 수는 함수가 기대하는 매개변수의 수와 일치해야 합니다.
    
 
    function buildName(firstName: string, lastName: string) {
     return firstName + " " + lastName;
 }
 
 let result1 = buildName("Bob");                  // 오류, 너무 적은 매개변수
 let result2 = buildName("Bob", "Adams", "Sr.");  // 오류, 너무 많은 매개변수
-let result3 = buildName("Bob", "Adams");         // 아, 딱 맞습니다
+let result3 = buildName("Bob", "Adams");         // 정확함
 
    
-
    JavaScript에서 모든 매개변수는 선택 사항이며 매개변수를 원하는 대로 사용하지 않을 수 있습니다.
    그렇게 되면 그 매개변수들의 값은 undefined입니다.
-TypeScript에서 선택적인 매개변수를 사용하려면 선택적으로 사용하려는 매개변수의 끝에 ?를 추가하세요.
    
-
    예를 들어 위에서 사용한 lastName 매개변수를 선택적으로 사용할 수 있도록 합니다:
    
+
    JavaScript에서는 모든 매개변수가 선택적이고, 사용자는 적합하다고 생각하면 그대로 둘 수 있습니다.
+그렇게 둔다면 그 값은 undefined가 됩니다.
+TypeScript에서도 선택적 매개변수를 원한다면 매개변수 이름 끝에 ? 를 붙임으로써 해결할 수 있습니다.
+그 예시로 성을 선택적 매개변수로 하는 경우를 들어보겠습니다:
    
 
    function buildName(firstName: string, lastName?: string) {
     if (lastName)
         return firstName + " " + lastName;
@@ -785,67 +848,82 @@ 
    return firstName;
 }
 
-let result1 = buildName("Bob");                  // 올바르게 작동합니다
+let result1 = buildName("Bob");                  // 지금은 바르게 동작
 let result2 = buildName("Bob", "Adams", "Sr.");  // 오류, 너무 많은 매개변수
-let result3 = buildName("Bob", "Adams");         // 아, 딱 맞습니다
+let result3 = buildName("Bob", "Adams");         // 정확함
 
    
-
    모든 선택적 매개변수는 필수 매개변수를 따라와야 합니다.
    last name 대신 first name을 선택적 매개변수로 만들고 싶다면 함수의 매개변수 순서를 변경해야 합니다.
    즉 목록의 first name을 마지막에 넣어야합니다.
    
-
    TypeScript에서 사용자가 매개변수를 제공하지 않거나 사용자가 대신 undefined를 전달하더라도 매개변수가에 할당되는 값을 설정할 수 있습니다.
    이것을 기본 매개변수(default-initialized parameters)라고 합니다.
    
-
    앞의 예제를 따라 last name의 기본값을 "Smith"로 설정해 보겠습니다.
    
+
    어느 선택적 매개변수든 반드시 매개변수 정의가 필요합니다.
+lastName 대신 firstName을 선택적으로 하고 싶다면 매개변수의 순서를 변경해야 합니다.
    
+
    TypeScript에서는 유저가 값을 제공하지 않거나 undefined로 했을 때에 할당될 매개변수의 값을 정해 놓을 수도 있습니다.
+이것을 기본-초기화 매개변수라고 합니다.
+이전 예시에서 lastName을 "Smith" 라고 지정해 보겠습니다.
    
 
    function buildName(firstName: string, lastName = "Smith") {
     return firstName + " " + lastName;
 }
 
-let result1 = buildName("Bob");                  // 올바르게 작동하며 "Bob Smith"를 반환합니다
-let result2 = buildName("Bob", undefined);       // 여전히 작동하며 "Bob Smith"를 반환합니다.
+let result1 = buildName("Bob");                  // 올바르게 동작, "Bod Smith" 반환
+let result2 = buildName("Bob", undefined);       // 여전히 동작, 역시 "Bob Smith" 반환
 let result3 = buildName("Bob", "Adams", "Sr.");  // 오류, 너무 많은 매개변수
-let result4 = buildName("Bob", "Adams");         // 아, 딱 맞습니다
+let result4 = buildName("Bob", "Adams");         // 정확함
 
    
-
    필수 매개변수의 뒤에 오는 기본 매개변수는 선택적 매개변수로 취급되어 함수를 호출할 때 선택적 매개변수처럼 생략할 수 있습니다.
    이것은 선택적 매개변수와 후행 기본 매개변수가 해당 타입의 공통점을 공유한다는 것을 의미하므로  
    
-
    둘 다
    
+
    모든 필수 매개변수 뒤에 오는 기본-초기화 매개변수는 선택적으로 처리되며, 선택적 매개변수와 마찬가지로 해당 함수를 호출할 때 생략할 수 있습니다.
+이는 선택적 매개변수와 뒤따르는 기본 매개변수의 타입들이 공통성을 공유함을 의미합니다, 그래서 이 두 가지
    
 
    function buildName(firstName: string, lastName?: string) {
     // ...
 }
 
    
-
    그리고
    
+
    와
    
 
    function buildName(firstName: string, lastName = "Smith") {
     // ...
 }
 
    
-
    (firstName: string, lastName?: string) => string 동일한 타입을 공유합니다.
    lastName의 기본 값은 타입에서 사라지고 매개변수가 선택 사항이라는 사실만 남겨졌습니다.
    
-
    일반 선택적 매개변수와 달리 기본 매개변수는 필수 매개변수 뒤에 나올 필요가 없습니다.
    기본 매개변수가 필수 매개변수 앞에 오는 경우 사용자는 명시적으로 undefined를 전달하여 기본 초기화된 값을 가져와야 합니다.
    
-
    예를 들어 firstName에 기본 초기화만 있는 마지막 예제를 작성할 수 있습니다:
    
+
    는 (firstName: string, lastName?: string) => string 라는 공통된 타입을 공유합니다.
+lastName의 기본값은 타입에서 사라지고 오직 선택적 매개변수라는 사실만 남깁니다.
    
+
    순수한 선택적 매개변수와는 다르게 기본-초기화 매개변수는 필수 매개변수 뒤에 오는 것이 강요되지 않습니다.
+만약 기본-초기화 매개변수가 필수 매개변수보다 앞에 오게 된다면 사용자가 명시적으로 undefined 를 전달해 주어야 기본-초기화 매개변수를 볼 수 있습니다.
+앞서 사용했던 예시에 기본 초기화를 firstName에 적용한 것입니다:
    
 
    function buildName(firstName = "Will", lastName: string) {
     return firstName + " " + lastName;
 }
 
 let result1 = buildName("Bob");                  // 오류, 너무 적은 매개변수
 let result2 = buildName("Bob", "Adams", "Sr.");  // 오류, 너무 많은 매개변수
-let result3 = buildName("Bob", "Adams");         // 좋아요 "Bob Adams"를 반환합니다
-let result4 = buildName(undefined, "Adams");     // 좋아요 "Will Adams"를 반환합니다
+let result3 = buildName("Bob", "Adams");         // 성공, "Bob Adams" 반환
+let result4 = buildName(undefined, "Adams");     // 성공, "Will Adams" 반환
 
    
 
    나머지 매개변수 (Rest Parameters)
    
-
    필수 매개변수와 선택적 매개변수 그리고 기본 매개변수 모두 공통점이 하나 있습니다: 한 번에 하나의 매개변수에 대해 이야기합니다.
    때로는 여러 매개변수를 그룹으로 사용하거나 함수가 마지막으로 가져올 매개변수의 수를 모를 수 있습니다.
    JavaScript에서는 모든 함수 본문에서 볼 수 있는 arguments를 사용하여 인수를 직접 사용할 수 있습니다.
    
-
    TypeScript에서는 다음과 같은 인수를 변수로 함께 모을수 있습니다:
    
+
    필수, 선택적, 기본 매개변수는 한 번에 하나의 매개변수만을 가지고 이야기합니다.
+때로는 다수의 매개변수를 그룹 지어 작업하기를 원하거나, 함수가 최종적으로 얼마나 많은 매개변수를 취할지 모를 때도 있을 것입니다.
+JavaScript에서는 모든 함수 내부에 위치한 arguments라는 변수를 사용해 직접 인자를 가지고 작업할 수 있습니다.
    
+
    TypeScript에서는 이 인자들을 하나의 변수로 모을 수 있습니다:
    
 
    function buildName(firstName: string, ...restOfName: string[]) {
     return firstName + " " + restOfName.join(" ");
 }
 
+// employeeName 은 "Joseph Samuel Lucas MacKinzie" 가 될것입니다.
 let employeeName = buildName("Joseph", "Samuel", "Lucas", "MacKinzie");
 
    
-
    나머지 매개변수는 무한적인 수의 선택적 매개변수로 처리됩니다.
    Rest 매개변수에 인수를 전달할 때는 원하는 만큼 사용할 수 있으며 심지어 통과할 수 없습니다.
    컴파일러는 줄임표 (...) 다음에 전달된 인수들을 배열을 작성하여 함수에서 사용할 수 있습니다.
    
-
    줄임표(...)는 나머지 매개변수가 있는 함수의 타입에도 사용됩니다:
    
+
    나머지 매개변수는 선택적 매개변수들의 수를 무한으로 취급합니다.
+나머지 매개변수로 인자들을 넘겨줄 때는 당신이 원하는 만큼 넘겨 줄 수도 있습니다; 아무것도 넘겨주지 않을 수도 있습니다.
+컴파일러는 생략 부호 (...) 뒤의 이름으로 전달된 인자 배열을 빌드하여 함수에서 사용할 수 있도록 합니다.
    
+
    생략 부호는 나머지 매개변수가 있는 함수의 타입에도 사용됩니다:
    
 
    function buildName(firstName: string, ...restOfName: string[]) {
     return firstName + " " + restOfName.join(" ");
 }
 
 let buildNameFun: (fname: string, ...rest: string[]) => string = buildName;
 
    
-
    this
    
-
    JavaScript에서 this를 사용법을 배우는 것은 일종의 통과 의례입니다.
    TypeScript는 JavaScript의 상위 집합이기 때문에 TypeScript 개발자들도 this을 사용하는 방법과 올바르게 사용되고 있지 않을 때를 찾아내는 방법을 배워야 합니다.
    JavaScript에서 this가 어떻게 작동하는지 알아야 한다면 Yehuda Katz의 Understanding JavaScript Function Invocation and "this"를 먼저 읽어보세요.
    Yehuda의 글에는 this의 내부 동작을 잘 설명하기 때문에 여기서는 기본적인 내용만 다룰 것입니다.
    
-
    this와 화살표 함수 (this and arrow functions)
    
-
    JavaScript에서 this는 함수가 호출될 때 설정되는 변수입니다.
    매우 강력하고 유연한 기능이지만 함수가 실행되는 상황에 대해 항상 알고 있어야 하는 시간이 듭니다.
    특히 함수를 반환하거나 함수를 인수로 전달할 때 악명 높을 정도로 혼란스럽습니다.
    
-
    예제를 살펴보겠습니다:
    
+
    this
    
+
    this 가 JavaScript에서 어떻게 쓰이는지 아는 것은 일종의 통과의례입니다.
+TypeScript는 JavaScript의 상위 집합이므로 TypeScript 개발자들 역시 this가 어떻게 쓰이는지 또는 this가 잘못 쓰일 때를 발견하는 방법을 배울 필요가 있습니다.
+다행히도 TypeScript는 몇 가지 기술들로 잘못된 this 사용을 잡아낼 수 있습니다.
+만약 JavaScript에서 this가 어떻게 동작하는지 알고 싶다면 먼저 Yehuda Katz의 글 JavaScript 함수 호출과 "this" 이해하기 을 읽도록 합니다.
+Yehuda의 글은 this의 내부 동작을 아주 잘 설명하므로, 여기서는 기본만 다룰 것입니다.
    
+
    this와 화살표 함수 (this and arrow functions)
    
+
    JavaScript에서, this는 함수가 호출될 때 정해지는 변수입니다.
+매우 강력하고 유연한 기능이지만 이것은 항상 함수가 실행되는 콘텍스트에 대해 알아야 한다는 수고가 생깁니다.
+특히 함수를 반환하거나 인자로 넘길 때의 혼란스러움은 악명 높습니다.
    
+
    예시를 봅시다:
    
 
    let deck = {
     suits: ["hearts", "spades", "clubs", "diamonds"],
     cards: Array(52),
@@ -864,14 +942,21 @@ 
    alert("card: " + pickedCard.card + " of " + pickedCard.suit);
 
    
-
    createCardPicker는 자체적으로 함수를 반환하는 함수입니다.
    예제를 실행하려고 하면 alert 대신 오류가 발생합니다.
    createCardPicker에 의해 생성된 함수에서 사용되는 this가 deck 객체 대신에 window로 설정되어 있기 때문입니다.
    왜냐하면 cardPicker()는 자기 자신을 호출하기 때문입니다.
    이와 같이 최상위 비-메서드 구문 호출은 this에 window를 사용합니다.
    (주의사항 : 엄격모드(strict mode)에서 this는 window보다는 undefined가 될 것입니다).
    
-
    나중에 사용할 함수를 반환하기 전에 함수에 올바른 this가 연결되도록하여 이를 해결할 수 있습니다.
-이렇게하면 나중에 어떻게 사용되든 상관없이 원래의 deck객체를 볼 수 있습니다.
    이를 위해 함수 표현식을 ECMAScript 6의 화살표 구문으로 변경하여 사용합니다.
    화살표 함수는 호출된 곳이 아닌 함수가 생성 된 곳에서 this를 캡처합니다:
    
+
    createCardPicker가 자기 자신을 반환하는 함수임을 주목해 주세요.
+이 예제를 작동시키면 기대했던 경보 창 대신 오류가 발생할 것입니다.
+createCardPicker에 의해 생성된 함수에서 사용 중인 this가 deck 객체가 아닌 window에 설정되었기 때문입니다.
+cardPicker()의 자체적인 호출 때문에 생긴 일입니다.
+최상위 레벨에서의 비-메서드 문법의 호출은 this를 window로 합니다.
+(Note: strict mode에서는 this가 window 대신 undefined 가 됩니다. )
    
+
    이 문제는 나중에 사용할 함수를 반환하기 전에 바인딩을 알맞게 하는 것으로 해결할 수 있습니다.
+이 방법대로라면 나중에 사용하는 방법에 상관없이 원본 deck 객체를 계속해서 볼 수 있습니다.
+이를 위해, 함수 표현식을 ES6의 화살표 함수로 바꿀 것입니다.
+화살표 함수는 함수가 호출 된 곳이 아닌 함수가 생성된 쪽의 this를 캡처합니다:
    
 
    let deck = {
     suits: ["hearts", "spades", "clubs", "diamonds"],
     cards: Array(52),
     createCardPicker: function() {
-        // 주의: 아래 줄은 이제 화살표 함수입니다. 여기에서 'this'를 캡처할 수 있습니다.
+        // NOTE: 아랫줄은 화살표 함수로써, 'this'를 이곳에서 캡처할 수 있도록 합니다
         return () => {
             let pickedCard = Math.floor(Math.random() * 52);
             let pickedSuit = Math.floor(pickedCard / 13);
@@ -886,15 +971,18 @@ 
    alert("card: " + pickedCard.card + " of " + pickedCard.suit);
 
    
-
    더 좋은 점은 컴파일러에 --noImplicitThis 신호를 넘겨주면 TypeScript가 실수를 했을 때 경고를 합니다.
    this.suits[pickedSuit]에서 this는 any 타입입니다.
    
-
    this parameters
    
-
    불행히도 this.suits [pickedSuit]의 타입은 여전히any입니다.
    왜냐하면 this는 객체 리터럴 내부의 함수 표현식에서 왔기 때문입니다.
    이 문제를 해결하기 위해 명시적으로 this 매개변수를 제공할 수 있습니다.  
    
-
    this 매개변수는 함수의 매개변수 목록에서 처음 나오는 가짜 매개변수입니다:
    
+
    --noImplicitThis 플래그를 컴파일러에 전달하는 실수를 하게 된다면 TypeScript는 경고를 표시할 것입니다.
+this.suits[pickedSuit] 의 this는 any 타입인 것을 짚고 넘어가겠습니다.
    
+
    this 매개변수 (this parameter)
    
+
    불행히도 this.suits[pickedSuit]의 타입은 여전히 any입니다.
+this가 객체 리터럴 내부의 함수에서 왔기 때문입니다.
+이것을 고치기 위해 명시적으로 this 매개변수를 줄 수 있습니다.
+this 매개변수는 함수의 매개변수 목록에서 가장 먼저 나오는 가짜 매개변수입니다.
    
 
    function f(this: void) {
-    // 이 분리된 함수에서 'this'를 사용할 수 없는지 확인해보세요.
+    // 독립형 함수에서 `this`를 사용할 수 없는 것을 확인함
 }
 
    
-
    위의 예제에서 Card와 Deck에 몇 가지 인터페이스를 추가하여 타입을 더 명확하고 쉽게 재사용하기 쉽게 만들 수 있도록 하겠습니다
    
+
    명확하고 재사용하기 쉽게 Card와 Deck 두 가지 인터페이스 타입들을 예시에 추가해 보겠습니다.
    
 
    interface Card {
     suit: string;
     card: number;
@@ -907,7 +995,7 @@ 
    this parameters
    
 let deck: Deck = {
     suits: ["hearts", "spades", "clubs", "diamonds"],
     cards: Array(52),
-    // 주의사항 : 이 함수는 이제 반드시 Deck 타입이어야합니다
+    // NOTE: 아래 함수는 이제 callee가 반드시 Deck 타입이어야 함을 명시적으로 지정합니다.
     createCardPicker: function(this: Deck) {
         return () => {
             let pickedCard = Math.floor(Math.random() * 52);
@@ -923,58 +1011,67 @@ 
    this parameters
    
 
 alert("card: " + pickedCard.card + " of " + pickedCard.suit);
 
    
-
    이제 TypeScript는createCardPicker가 Deck 객체에서 호출될 것으로 예상합니다.
    즉 this는 any가 아닌 Deck 타입입니다. 따라서 --noImplicitThis는 오류를 발생시키지 않습니다.
    
-
    콜백에서의 this 매개변수 (this parameters in callbacks)
    
-
    함수를 나중에 호출할 라이브러리에 전달할 때 콜백에서 this를 사용하여 오류가 발생할 수도 있습니다.
    왜냐하면 콜백을 호출하는 라이브러리가 표준 함수처럼 호출하기 때문에 this는 undefined가 될 것입니다.
    
-
    때때로 this 매개변수를 사용하여 콜백 오류를 방지할 수도 있습니다.
-첫 번째, 라이브러리 작성자는 콜백 타입에 this를 사용하여 annotate를 달아야 합니다:
    
+
    이제 TypeScript는 createCardPicker가 Deck 객체에서 호출된다는 것을 알게 됐습니다.
+이것은 this가 any 타입이 아니라 Deck 타입이며 따라서 --noImplicitThis 플래그가 어떤 오류도 일으키지 않는다는 것을 의미합니다.
    
+
    콜백에서 this 매개변수 (this parameters in callbacks)
    
+
    나중에 호출할 콜백 함수를 라이브러리에 전달할 때 this 때문에 오류가 발생할 수 있습니다.
+라이브러리는 콜백을 일반 함수처럼 호출하므로 this는 undefined가 됩니다.
+일부 작업에서는 this 매개변수를 콜백 오류를 막는데 사용할 수 있습니다.
+먼저 라이브러리 작성자는 콜백 타입을 this로 표시를 해주어야 합니다.
    
 
    interface UIElement {
     addClickListener(onclick: (this: void, e: Event) => void): void;
 }
 
    
-
    this : void는 addClickListener가 onclick이 this 타입을 필요로 하지 않는 함수라는 것을 의미합니다.
    
-
    두 번째, this를 사용하여 호출 코드와 함께 annotate를 달아야 합니다:
    
+
    this: void는 addClickListener가 onclick이 this타입을 요구하지 않는 함수가 될 것으로 예상하는 것을 의미합니다.
+두 번째로, 호출 코드를 this로 표시합니다.
    
 
    class Handler {
     info: string;
     onClickBad(this: Handler, e: Event) {
-        // 이런, 여기서 this를 사용했어요. 이 콜백을 사용하면 충돌으로 런타임 오류가 발생합니다.
+        // 이런, `this`가 여기서 쓰이는군요. 이 콜백을 쓰면 런타임에서 충돌을 일으키겠군요
         this.info = e.message;
     }
 }
 let h = new Handler();
 uiElement.addClickListener(h.onClickBad); // 오류!
 
    
-
    this가 annotated되어 있으면 onClickBad는 반드시 Handler의 인스턴스에서 호출되어야한다는 것을 명시해야 합니다.
    그런 다음 TypeScript는 addClickListener에 this : void가 있는 함수가 필요하다는 것을 발견합니다.
    오류를 해결하려면 this의 타입을 수정하세요:
    
+
    this로 표시를 한 상태에서 onClickBad가 반드시 Handler의 인스턴스로써 호출되어야 함을 명시해 주어야 합니다.
+그러면 TypeScript는 addClickListener가 this: void를 갖는 함수를 필요로 한다는 것을 감지합니다.
+오류를 고치기 위해 this의 타입을 바꿔줍니다:
    
 
    class Handler {
     info: string;
     onClickGood(this: void, e: Event) {
-        // this의 타입이 void이기 때문에 여기서는 사용할 수 없습니다!
+        // void 타입이기 때문에 this는 이곳에서 쓸 수 없습니다!
         console.log('clicked!');
     }
 }
 let h = new Handler();
 uiElement.addClickListener(h.onClickGood);
 
    
-
    onClickGood는 this의 타입을 void로 지정하기 때문에 addClickListener에 전달할 수 있습니다.
    물론 this는 또한 this.info를 사용할 수 없다는 것을 의미합니다.
    두 가지 모두를 사용하려면 화살표 함수를 사용해야 합니다:
    
+
    onClickGood이 this 타입을 void로 지정하고 있기 때문에 addClickListener로 넘겨지는데 적합합니다.
+물론, 이것이 this.info를 쓸 수 없는 것을 의미하기도 합니다.
+만약 당신이 this.info까지 원한다면 화살표 함수를 사용해야 할 겁니다:
    
 
    class Handler {
     info: string;
     onClickGood = (e: Event) => { this.info = e.message }
 }
 
    
-
    이것은 화살표 함수가 this를 캡처하지 않기 때문에 효과적입니다.
    때문에 기대하는 것 같이 항상 this : void를 넘겨줄 수 있습니다.
    
-
    단점은 Handler 타입의 객체마다 하나의 화살표 함수가 생성된다는 것입니다.
    반면에 메서드는 한 번만 만들어지고 핸들러의 프로토 타입에 소속됩니다.
    이러한 객체는 핸들러 타입의 모든 객체 사이에 공유됩니다.
    
+
    이러한 작업은 화살표 함수가 외부의 this를 사용하기 때문에 가능하므로 this: void일 것으로 기대하는 무언가라면 전달에 문제가 없습니다.
+Handler 타입 객체마다 하나의 화살표 함수가 작성된다는 점이 단점입니다.
+반면, 메서드들은 하나만 작성되어 Handler의 프로토타입에 붙습니다.
+그들은 Handler 타입의 모든 객체 간에 공유됩니다.
    
 
    오버로드 (Overloads)
    
-
    JavaScript는 본질적으로 매우 동적인 언어입니다.
    단일 JavaScript 함수가 전달된 인수의 형태를 기반으로 서로 다른 타입의 객체를 반환하는 것은 드문 일이 아닙니다.
    
+
    JavaScript는 본질적으로 매우 동적인 언어입니다.
+하나의 JavaScript 함수가 전달된 인자의 형태에 따라 다른 타입의 객체들을 반환하는 것은 흔한 일입니다.
    
 
    let suits = ["hearts", "spades", "clubs", "diamonds"];
 
 function pickCard(x): any {
-    // 객체 / 배열로 작업하고 있는지 확인해보세요
-    // 그렇다면 그것들은 덱을 주고 사용자는 카드를 선택할 것입니다.
+    // 인자가 배열 또는 객체인지 확인
+    // 만약 그렇다면, deck이 주어지고 card를 선택합니다.
     if (typeof x == "object") {
         let pickedCard = Math.floor(Math.random() * x.length);
         return pickedCard;
     }
-    // 그렇지 않으면 카드를 선택하게하세요.
+    // 그렇지 않다면 그냥 card를 선택합니다.
     else if (typeof x == "number") {
         let pickedSuit = Math.floor(x / 13);
         return { suit: suits[pickedSuit], card: x % 13 };
@@ -988,20 +1085,25 @@ 
    오버로
 let pickedCard2 = pickCard(15);
 alert("card: " + pickedCard2.card + " of " + pickedCard2.suit);
 
    
-
    여기서 pickCard 함수는 사용자가 무엇을 전달했는지에 따라 두 개의 서로 다른 내용을 반환합니다.
    사용자가 deck를 나타내는 객체를 전달하면 함수가 card를 선택합니다.
    사용자가 card를 선택하면 그들이 선택한 card를 알려줍니다.
    하지만 이것을 어떻게 타입 시스템에 설명할까요?
    
-
    이에 대한 대답은 오버로드 목록과 동일한 함수에 대한 여러 함수 타입을 제공하는 것이다.
    이 목록은 컴파일러가 함수 호출을 해결하는 데 사용할 것입니다.
    pickCard가 받아들일 수 있는 것과 그것이 반환하는 것을 기술한 오버로드 목록을 작성해 보세요.
    
+
    여기 사용자가 전달하는 것에 따라 두 가지 다른 결과를 반환하는 함수가 있습니다.
+사용자가 deck을 의미하는 객체 값을 전달한다면 함수가 카드를 선택합니다.
+사용자가 카드를 선택하면 선택한 카드가 무엇인지 대답해 줍니다.
+하지만 타입 시스템에서 이것을 어떻게 구현할 것입니까?
    
+
    정답은 오버로드 목록으로 동일한 함수에 다중 함수 타입을 제공하는 것입니다.
+오버로드 목록은 컴파일러가 함수 호출들을 해결할 때 사용하는 것입니다.
+오버로드 목록으로 pickCard가 동작을 승인하고 반환하는 것을 구현해 봅시다:
    
 
    let suits = ["hearts", "spades", "clubs", "diamonds"];
 
 function pickCard(x: {suit: string; card: number; }[]): number;
 function pickCard(x: number): {suit: string; card: number; };
 function pickCard(x): any {
-    // 객체 / 배열로 작업하고 있는지 확인해보세요
-    // 그렇다면 그것들은 덱을 주고 사용자는 카드를 선택할 것입니다.
+    // 인자가 배열 또는 객체인지 확인
+    // 만약 그렇다면, deck이 주어지고 card를 선택합니다.
     if (typeof x == "object") {
         let pickedCard = Math.floor(Math.random() * x.length);
         return pickedCard;
     }
-    // 그렇지 않으면 카드를 선택하게하세요.
+    // 그렇지 않다면 그냥 card를 선택합니다.
     else if (typeof x == "number") {
         let pickedSuit = Math.floor(x / 13);
         return { suit: suits[pickedSuit], card: x % 13 };
@@ -1015,9 +1117,13 @@ 
    오버로
 let pickedCard2 = pickCard(15);
 alert("card: " + pickedCard2.card + " of " + pickedCard2.suit);
 
    
-
    이런 변화로 인해 오버로드가 pickCard 함수에 대한 타입-체크 호출을 제공합니다.
    
-
    컴파일러가 올바른 타입 검사를 선택하기 위해 기본 JavaScript와 비슷한 프로세스를 수행합니다.
    오버로드 목록을 살펴보고 제공된 매개변수를 사용하여 함수를 호출하는 첫 번째 오버로드 시도를 계속합니다.
    일치하는 것을 찾으면 이 오버로드를 올바른 오버로드로 선택합니다.
    이러한 이유 때문에 주문이 많아지면 가장 구체적인 것에서 가장 덜 구체적인 것으로 오버로드합니다.
    
-
    function pickCard (x) : any 조각은 오버로드 목록의 일부가 아니므로 두 개의 오버로드만 있습니다:
    하나는 객체를 취하고 하나는 숫자를 취합니다.
    pickCard를 다른 매개 변수 타입과 함께 호출하면 오류가 발생합니다.
    
+
    이 변화를 통해, 오버로드는 pickCard 함수에 대해 타입 검사 호출을 제공합니다.
    
+
    컴파일러가 알맞은 타입 검사를 하기 위해서, JavaScript와 비슷한 프로세스를 따릅니다.
+오버로드 목록에서 첫 번째 오버로드를 진행하면서 제공된 매개변수를 사용하여 함수를 호출하려고 시도합니다.
+만약 일치하게 된다면 해당 오버로드를 알맞은 오버로드로 선택하여 작업을 수행합니다.
+이러한 이유로 가장 구체적인 것부터 오버로드 리스팅을 하는 것이 일반적입니다.
    
+
    위 예제에서 function pickCard(x): any는 오버로드 목록에 해당되지 않음을 유의하세요, 그래서 두 가지 오버로드만을 가집니다: 객체를 받는것 하나와 숫자를 받는 것 하나.
+다른 매개변수 타입으로 pickCard를 호출하는 것은 오류가 발생합니다.
    
 
                                 
                                 
    
@@ -1061,7 +1167,7 @@ 
    No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"함수","level":"3.5","depth":1,"next":{"title":"제네릭","level":"3.6","depth":1,"path":"pages/Generics.md","ref":"pages/Generics.md","articles":[]},"previous":{"title":"클래스","level":"3.4","depth":1,"path":"pages/Classes.md","ref":"pages/Classes.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Functions.md","mtime":"2019-06-14T05:32:52.239Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"함수","level":"3.5","depth":1,"next":{"title":"제네릭","level":"3.6","depth":1,"path":"pages/Generics.md","ref":"pages/Generics.md","articles":[]},"previous":{"title":"클래스","level":"3.4","depth":1,"path":"pages/Classes.md","ref":"pages/Classes.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Functions.md","mtime":"2020-04-22T15:29:36.174Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Generics.html b/pages/Generics.html
index e508bb90..1e119cbc 100644
--- a/pages/Generics.html
+++ b/pages/Generics.html
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
    • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
  • 
+        
  • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
    • 
+    
+        
  • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
  • 릴리즈 노트
    • 
+        
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
    • 
+    
+
+    
 
     
  • 
 
@@ -712,114 +758,141 @@ 
    
                                 
    
                                 
                                 
    소개 (Introduction)
    
-
    소프트웨어 공학의 주요 부분은 명확하고 일관된 API를 가질뿐만 아니라 재사용 가능한 컴포넌트를 구축하는 것입니다.
    현재의 데이터 뿐만 아니라 미래의 데이터에 대해서도 처리할 수 있는 컴포넌트는 대형 소프트웨어 시스템 구축을 위한 가장 유연한 기능을 제공할 것입니다.
    
-
    C# 및 Java와 같은 언어에서 재사용 가능한 컴포넌트를 만들기 위한 주요 도구 중 하나는 제네릭 즉 단일 타입이 아닌 다양한 타입을 처리할 수 있는 컴포넌트를 만드는 것입니다.
    이를 통해 사용자는 컴포넌트를 사용할 때 자신만의 타입을 사용할 수 있습니다.
    
+
    잘 정의되고 일관된 API뿐만 아닌 재사용 가능한 컴포넌트를 구축하는 것도 소프트웨어 엔지니어링에서의 주요한 부분입니다.
+현재의 데이터와 미래의 데이터 모두를 다룰 수 있는 컴포넌트는 거대한 소프트웨어 시스템을 구성하는 데 있어 가장 유연한 능력을 제공할 것입니다.
    
+
    C#과 Java 같은 언어에서, 재사용 가능한 컴포넌트를 생성하는 도구상자의 주요 도구 중 하나는 제네릭입니다, 즉, 단일 타입이 아닌 다양한 타입에서 작동하는 컴포넌트를 작성할 수 있습니다.
+사용자는 제네릭을 통해 여러 타입의 컴포넌트나 자신만의 타입을 사용할 수 있습니다.
    
 
    제네릭의 Hello World (Hello World of Generics)
    
-
    우선 제네릭의 "Hello World" 즉 identity 함수를 만들어 봅시다.
    이 identity 함수는 전달된 것을 그대로 반환하는 함수입니다.
    이는 echo 명령과 비슷한 방식으로 생각하면 됩니다.
    
-
    제네릭이 없다면 identity 함수에 특정 타입을 부여해야 합니다.
    
+
    먼저 제네릭의 "hello world"인 identity 함수를 해봅시다.
+identity 함수는 인수로 무엇이 오던 그대로 반환하는 함수입니다.
+echo 명령과 비슷하게 생각할 수 있습니다.
    
+
    제네릭이 없다면, identity 함수에 특정 타입을 주어야 합니다:
    
 
    function identity(arg: number): number {
     return arg;
 }
 
    
-
    또는 any 타입을 사용하여 identity 함수를 만들 수 있습니다.
    
+
    또는 any 타입을 사용하여 identity 함수를 기술할 수 있습니다:
    
 
    function identity(arg: any): any {
     return arg;
 }
 
    
-
    any를 사용하는 것은 분명히 함수가 arg에 대한 모든 타입을 전달 받을 수 있게되지만 실제로 함수가 반환할 때 그 타입이 무엇이었는지에 대한 정보를 잃어버립니다.
    만약 숫자를 인수로 전달하면 어떤 타입이든 반환횔 수 있다는 것을 알 수 있습니다.
    
-
    대신 어떤 타입이 반환될 것인지를 나타내는 데 사용할 수 있는 방식으로 인수 타입을 정하는 방법이 필요합니다.
    여기서는 값이 아닌 타입을 처리하는 특별한 종류의 변수인 타입 변수(type variable)을 사용할 것입니다.
    
+
    any를 쓰는 것은 함수의 arg가 어떤 타입이든 받을 수 있다는 점에서 제네릭이지만, 실제로 함수가 반환할 때 어떤 타입인지에 대한 정보는 잃게 됩니다.
+만약 number 타입을 넘긴다고 해도 any 타입이 반환된다는 정보만 얻을 뿐입니다.
    
+
    대신에 우리는 무엇이 반환되는지 표시하기 위해 인수의 타입을 캡처할 방법이 필요합니다.
+여기서는 값이 아닌 타입에 적용되는 타입 변수 를 사용할 것입니다.
    
 
    function identity<T>(arg: T): T {
     return arg;
 }
 
    
-
    identity 함수에 타입변수 T 를 추가했습니다.
    이 T 는 함수 사용자가 제공한 타입(예: number)를 캡처하여 나중에 해당 정보를 사용할 수 있도록 합니다.
    또한 T 를 다시 반환 타입으로 사용합니다.
    자세히 보면 인수와 반환 타입에 동일한 타입이 사용되는 것을 볼 수 있습니다.
    이를 통해 함수의 안과 밖에서 타입에 대한 정보를 넘길 수 있습니다.
    
-
    이러한 모습의 identity 함수는 다양한 타입을 처리할 수 있기 때문에 일반적이라고 할 수 있습니다.
    any 를 사용하는 것과는 달리 인수와 반환 타입에 숫자를 사용하는 처음의 identity 함수와 동일합니다.(즉 어떠한 정보도 잃어버리지 않습니다)
    
-
    제네릭 identity 함수를 만든 후 두 가지 방법 중 하나로 호출할 수 있습니다.
    첫번째 방법은 타입 인수를 포함한 모든 인수를 함수에 전달하는 것입니다.
    
-
    let output = identity<string>("myString");  // 반환 타입은 'string' 입니다.
+
    identity 함수에 T라는 타입 변수를 추가했습니다.
+T는 유저가 준 인수의 타입을 캡처하고 (예 - number), 이 정보를 나중에 사용할 수 있게 합니다.
+여기에서는 T를 반환 타입으로 다시 사용합니다. 인수와 반환 타입이 같은 타입을 사용하고 있는 것을 확인할 수 있습니다.
+이를 통해 타입 정보를 함수의 한쪽에서 다른 한쪽으로 운반할 수 있게끔 합니다.
    
+
    이 버전의 identity 함수는 타입을 불문하고 동작하므로 제네릭이라 할 수 있습니다.
+any를 쓰는 것과는 다르게 인수와 반환 타입에 number를 사용한 첫 번째 identity 함수만큼 정확합니다. (즉, 어떤 정보도 잃지 않습니다)
    
+
    일단 제네릭 identity 함수를 작성하고 나면, 두 가지 방법 중 하나로 호출할 수 있습니다.
+첫 번째 방법은 함수에 타입 인수를 포함한 모든 인수를 전달하는 방법입니다.
    
+
    let output = identity<string>("myString"); // 출력 타입은 'string'입니다.
 
    
-
    여기서는 함수 호출에 대한 인수 중 하나인 T 를 string 으로 명시적으로 정했으며 인수에는 () 를 사용하는 것과 달리 <> 를 사용했습니다.
    
-
    두번째 방법은 더 일반적인 방법이기도 합니다.
    여기서는 타입 인수 추론(type argument inference) 를 사용합니다.
    즉 함수에 전달하는 인수 타입에 따라 컴파일러가 자동으로 T 값을 설정합니다.
    
-
    let output = identity("myString");  // 반환 타입은 'string' 입니다.
+
    여기서 우리는 함수를 호출할 때의 인수 중 하나로써 T를 string으로 명시해 주고 인수 주변에 () 대신 <>로 감싸주었습니다.
    
+
    두 번째 방법은 아마 가장 일반적인 방법입니다. 여기서는 타입 인수 추론 을 사용합니다 -- 즉, 우리가 전달하는 인수에 따라서 컴파일러가 T의 값을 자동으로 정하게 하는 것입니다:
    
+
    let output = identity("myString"); //출력 타입은 'string'입니다.
 
    
-
    꺾쇠 괄호(<>) 안에 명시적으로 타입을 전달할 필요가 없습니다.
    컴파일러는 그저 "myString" 의 값을 보고 T 를 그 타입으로 설정합니다.
    타입 인수 추론은 코드를 더 짧고 가독성 있게 유지하는 유용한 도구가 될 수 있지만 보다 복잡한 예제에서는 컴파일러가 타입을 추론하지 못하면 앞의 예제에서 했던 것 처럼 타입 인수를 명시적으로 전달해야 할 수도 있습니다.
    
-
    제네릭 타입 변수 (Generic Type Variables)
    
-
    제네릭을 사용하기 시작할 때  identity 와 같은 제네릭 함수를 만들면 컴파일러는 함수 내부에 제네릭으로 타입이 지정된 매개변수를 올바르게 사용하도록 합니다.
    즉 실제로 이러한 매개변수를 모든 타입이 될 수 있는 것처럼 취급힙니다.
    
-
    앞에서 본 identity 함수를 보겠습니다.
    
+
    타입 인수를 꺾쇠괄호(<>)에 담아 명시적으로 전달해 주지 않은 것을 주목하세요; 컴파일러는 값인 "myString"를 보고 그것의 타입으로 T를 정합니다.
+인수 추론은 코드를 간결하고 가독성 있게 하는 데 있어 유용하지만 더 복잡한 예제에서 컴파일러가 타입을 유추할 수 없는 경우엔 명시적인 타입 인수 전달이 필요할 수도 있습니다.
    
+
    제네릭 타입 변수 작업 (Working with Generic Type Variables)
    
+
    제네릭을 사용하기 시작하면, identity와 같은 제네릭 함수를 만들 때, 컴파일러가 함수 본문에 제네릭 타입화된 매개변수를 쓰도록 강요합니다.
+즉, 이 매개변수들은 실제로 any 나 모든 타입이 될 수 있는 것처럼 취급할 수 있게 됩니다.
    
+
    앞에서 본 identity 함수를 살펴보도록 합니다:
    
 
    function identity<T>(arg: T): T {
-    return arg;
+  return arg;
 }
 
    
-
    각 호출과 함께 콘솔에 인수 arg 의 길이를 기록하고 싶다면 어떻게 해야할까요?
-이렇게 할지도 모릅니다:
    
+
    함수 호출 시마다 인수 arg의 길이를 로그에 찍으려면 어떻게 해야 합니까?
+아마 이것을 쓰고 싶을 겁니다:
    
 
    function loggingIdentity<T>(arg: T): T {
-    console.log(arg.length);  // 오류 : T는 .length 메소드를 가지고 있지 않습니다.
-    return arg;
+  console.log(arg.length); // 오류: T에는 .length 가 없습니다.
+  return arg;
 }
 
    
-
    컴파일러는 arg 의 .length 멤버를 사용하고 있다는 오류를 주지만 arg 모듈에는 이 멤버가 없다고 할 수는 없습니다.
    이전에 타입 변수가 모든 타입이 될 수 있다고 했습니다.
    따라서 누군가 .length 멤버가 없는 number 를 전달 할 수 있을 것입니다.
    
-
    실제로 이 함수가 T 대신 T 배열을 처리한다고 가정해 봅시다.
    그러면 배열을 처리할 수 있기 때문에 .length 멤버가 사용 가능해야 합니다.
    다른 타입의 배열을 생성하는 함수로 이것을 설명하겠습니다:
    
+
    이렇게 하면, 컴파일러는 arg의 멤버 .length를 사용하고 있다는 오류를 낼 것입니다만, 어떤 곳에서도 arg가 이 멤버가 있다는 것이 명시되어 있지 않습니다.
+이전에 이러한 변수 타입은 any나 모든 타입을 의미한다고 했던 것을 기억하십시오. 따라서 이 함수를 쓰고 있는 사용자는 .length 멤버가 없는 number를 대신 전달할 수도 있습니다
    
+
    실제로 이 함수가 T가 아닌 T의 배열에서 동작하도록 의도했다고 가정해봅시다. 배열로 사용하기 때문에 .length 멤버는 사용 가능합니다.
+다른 타입들의 배열을 만드는 것처럼 표현할 수 있습니다.
    
 
    function loggingIdentity<T>(arg: T[]): T[] {
-    console.log(arg.length);  // Array는 .length 멤버가 있습니다. 오류 없음.
-    return arg;
+  console.log(arg.length); // 배열은 .length를 가지고 있습니다. 따라서 오류는 없습니다.
+  return arg;
 }
 
    
-
    loggingIdentity 는 타입 매개 변수 T 를 인수로 받고 arg 는 T 배열이며 T 배열을 반환합니다.
    숫자 배열을 인수로 넘기면 T 가 number 에 바인딩 되기 때문에 숫자 배열을 반환할 것입니다.
    이렇게하면 모든 타입이 아닌 처리하고자 하는 타입의 일부로 제네릭 타입 변수 T 를 사용하여 유연성을 높일 수 있습니다.
    
-
    혹은 다음 예제와 같이 작성할 수 있습니다.
    
+
    loggingIdentity의 타입을 "제너릭 함수 loggingIdentity는 타입 매개변수 T와 T 배열인 인수 arg를 취하고 T 배열을 반환한다."라고 읽을 수 있습니다.
+만약 우리가 number 배열을 넘기면 T가 number에 바인딩 되므로 함수는 number 배열을 얻게 됩니다.
+전체 타입변수를 쓰는 것보다 하나의 타입으로써 제네릭 타입변수 T를 사용하는 것은 굉장한 유연함을 제공합니다.
    
+
    위 예제를 이렇게도 대체할 수 있습니다.
    
 
    function loggingIdentity<T>(arg: Array<T>): Array<T> {
-    console.log(arg.length);  // Array는 .length 멤버가 있습니다. 오류 없음.
-    return arg;
+  console.log(arg.length); // 배열은 .length를 가지고 있습니다. 따라서 오류는 없습니다.
+  return arg;
 }
 
    
-
    이미 다른 언어의 타입 스타일에 대해 잘 알고 있을 것입니다.
    다음장에서는 Array<T> 와 같이 자신만의 제네릭 타입을 만드는 방법을 다룰 것입니다.
    
+
    다른 언어들과 비슷한 이런 타입 스타일이 이미 익숙할 것입니다.
+다음 섹션에서는 어떻게 Array<T>와 같은 고유한 제네릭 타입을 만들 수 있는지에 대해 다루도록 하겠습니다.
    
 
    제네릭 타입 (Generic Types)
    
-
    이전 장에서는 다양한 타입의 함수를 처리하는 제네릭 identity 함수를 만들었습니다.
    이 장에서는 함수 자체의 타입과 제네릭 인터페이스를 만드는 방법에 대하여 살펴보겠습니다.
    
-
    제네릭 함수의 타입은 함수 선언과 비슷하게 타입 매개변수가 먼저 나열된 비 제네릭 함수의 타입은 같습니다.
    
+
    이전 섹션에서 우리는 타입을 초월한 제네릭 함수 identity를 만들었습니다.
+이번 섹션에서는 함수 자체의 타입과 제네릭 인터페이스를 만드는 방법에 대해 살펴보겠습니다.
    
+
    제네릭 함수의 타입은 함수 선언과 유사하게 타입 매개변수가 먼저 나열되는, 비-제네릭 함수의 타입과 비슷합니다.
    
 
    function identity<T>(arg: T): T {
-    return arg;
+  return arg;
 }
 
 let myIdentity: <T>(arg: T) => T = identity;
 
    
-
    타입 변수의 수와 타입 변수의 사용이 일치하다면 제네릭 타입 매개변수에 다른 이름을 사용할 수도 있습니다.
    
+
    또한 타입 변수의 수와 타입 변수가 사용되는 방식에 따라 타입의 제네릭 타입 매개변수에 다른 이름을 사용할 수도 있습니다.
    
 
    function identity<T>(arg: T): T {
-    return arg;
+  return arg;
 }
 
 let myIdentity: <U>(arg: U) => U = identity;
 
    
-
    제네릭 타입을 객체 리터럴 타입의 호출 형식으로도 사용할 수 있습니다:
    
+
    제네릭 타입을 객체 리터럴 타입의 함수 호출 시그니처로 작성할 수도 있습니다:
    
 
    function identity<T>(arg: T): T {
-    return arg;
+  return arg;
 }
 
-let myIdentity: {<T>(arg: T): T} = identity;
+let myIdentity: { <T>(arg: T): T } = identity;
 
    
-
    따라서 첫번째 제네릭 인터페이스를 작성하게 됩니다.
    앞의 예제에서 객체 리터럴을 가져와 인터페이스로 옮깁니다.
    
+
    이것들로 첫 번째 제네릭 인터페이스를 작성할 수 있습니다.
+앞서 예제의 객체 리터럴을 인터페이스로 가져옵니다:
    
 
    interface GenericIdentityFn {
-    <T>(arg: T): T;
+  <T>(arg: T): T;
 }
 
 function identity<T>(arg: T): T {
-    return arg;
+  return arg;
 }
 
 let myIdentity: GenericIdentityFn = identity;
 
    
-
    비슷한 예에서 제네릭 매개변수를 전체 인터페이스의 매개변수로 이동하려고 할 수 있습니다.
    이렇게하면 일반적으로 사용하는 유형(예: Dictionary 가 아닌 Dictionary<string>) 을 볼 수 있습니다.
    이것은 인터페이스의 다른 모든 멤버가 타입 매개변수를 볼 수 있게합니다.
    
+
    비슷한 예제에서, 제네릭 매개변수를 전체 인터페이스의 매개변수로 옮기고 싶을지도 모릅니다.
+이를 통해 제네릭 타입을 확인할 수 있습니다 (예 -  Dictionary 가 아닌 Dictionary<string>).
+이렇게 하면 인터페이스의 다른 모든 멤버가 타입 매개변수를 볼 수 있습니다.
    
 
    interface GenericIdentityFn<T> {
-    (arg: T): T;
+  (arg: T): T;
 }
 
 function identity<T>(arg: T): T {
-    return arg;
+  return arg;
 }
 
 let myIdentity: GenericIdentityFn<number> = identity;
 
    
-
    예제를 약간 다른 것으로 바꿔보겠습니다.
    제네릭 함수 대신 제네릭 타입의 일부인 비 제네릭 함수 signature로 설명하겠습니다.
    우리가 GenericIdentityFn 을 사용할 때 대응하는 타입 매개변수(여기서는 number)를 지정할 필요가 있고 호출 형식을 효과적으로 고정시킬 것입니다.
    언제 직접 호출 형식에 타입 파라미터를 삽입해야 하고 언제 인터페이스 자체에 삽입해야하는지를 이해하는 것이 타입의 어떤 측면이 제네릭인지 설명하는데 도움이 될 것입니다.
    
-
    제네릭 인터페이스 외에도 제네릭 클래스를 만들 수 있습니다.
    하지만 제네릭 열거형과 네임스페이스는 만들 수 없습니다.
    
+
    예제에 아주 작은 변화가 있었습니다.
+제네릭 함수를 작성하는 것 대신 제네릭 타입의 일부인 비-제네릭 함수 시그니처를 가집니다.
+GenericIdentityFn 함수를 사용할 때, 시그니처가 사용할 것을 효과적으로 제한할 특정한 타입 인수가 필요합니다 (여기서는 number).
+타입 매개변수를 호출 시그니처에 바로 넣을 때와 인터페이스 자체에 넣을 때를 이해하는 것은 타입의 제네릭 부분을 설명하는 데 도움이 됩니다.
    
+
    제네릭 인터페이스 외에도 제네릭 클래스를 만들 수 있습니다.
+제네릭 열거형과 네임스페이스는 만들 수 없습니다.
    
 
    제네릭 클래스 (Generic Classes)
    
-
    제네릭 클래스는 제네릭 인터페이스와 형태가 비슷합니다.
    제네릭 클래스는 클래스 이름 다음에 꺾쇠 괄호(<>)로 묶인 제네릭 타입 매개변수들을 갖습니다.
    
+
    제네릭 클래스와 제네릭 인터페이스는 형태가 비슷합니다.
+제네릭 클래스는 클래스 이름 뒤에 꺾쇠괄호(<>) 안쪽에 제네릭 타입 매개변수 목록을 가집니다.
    
 
    class GenericNumber<T> {
     zeroValue: T;
     add: (x: T, y: T) => T;
@@ -829,59 +902,65 @@ 
    È
 myGenericNumber.zeroValue = 0;
 myGenericNumber.add = function(x, y) { return x + y; };
 
    
-
    이것은 GenericNumber 문자 그대로 number 타입만 사용하도록 제한하는 것이 없다는 것을 눈치 챘을 것입니다.
-대신 string 이나 더 복잡한 객체를 사용할 수 있을 것입니다.
    
+
    이것은 GenericNumber 클래스의 문자 그대로 사용하지만 number 타입만 쓰도록 제한하는 것은 없습니다.
+대신 string이나 훨씬 복잡한 객체를 사용할 수 있습니다.
    
 
    let stringNumeric = new GenericNumber<string>();
 stringNumeric.zeroValue = "";
 stringNumeric.add = function(x, y) { return x + y; };
 
-alert(stringNumeric.add(stringNumeric.zeroValue, "test"));
+console.log(stringNumeric.add(stringNumeric.zeroValue, "test"));
 
    
-
    인터페이스와 마찬가지로 타입 매개변수를 클래스 자체에 두면 클래스의 모든 속성이 동일한 타입으로 작동하도록 할 수 있습니다.
    
-
    클래스 섹션에서 다루었던 것처럼 클래스에는 정적인 측면과 인스턴스 측면의 두가지 측면이 있습니다.
    제네릭 클래스는 정적 측면 보다는 인스턴스 측면에서만 제네릭이므로 클래스를 사용할 때 정적 멤버(static member)는 클래스의 타입 매개변수를 사용할 수 없습니다.
    
+
    인터페이스와 마찬가지로 클래스 자체에 타입 매개변수를 넣으면 클래스의 모든 프로퍼티가 동일한 타입으로 동작하는 것을 확인할 수 있습니다.
    
+
    클래스에서 다뤘던 것처럼 클래스는 두 가지 타입을 가집니다: 정적 측면과 인스턴스 측면.
+제네릭 클래스는 정적 측면이 아닌 인스턴스 측면에서만 제네릭이므로 클래스로 작업할 때 정적 멤버는 클래스의 타입 매개변수를 쓸 수 없습니다.
    
 
    제네릭 제약조건 (Generic Constraints)
    
-
    이전의 예제를 기억한다면 타입들에 어떤 기능이 있는지에 대한 지식이 있는 타입에서 작동하는 제네릭 함수를 작성해야 할 때가 있습니다.
    loggingIdentity 예제에서는 arg의 .length 프로퍼티에 접근하기를 원했지만 컴파일러는 모든 타입이 .length 속성을 가지고 있음을 증명할 수 없었습니다.
    그래서 컴파일러는 이러한 가정을 하지 않도록 경고를 줍니다.
    
+
    앞쪽의 예제를 기억한다면 특정 타입들로만 동작하는 제네릭 함수를 만들고 싶을 수 있습니다.
+앞서 loggingIdentity 예제에서 arg의 프로퍼티 .length에 접근하기를 원했지만, 컴파일러는 모든 타입에서 .length 프로퍼티를 가짐을 증명할 수 없으므로 경고합니다.
    
 
    function loggingIdentity<T>(arg: T): T {
-    console.log(arg.length);  // 오류 : T는 .length 메소드를 가지고 있지 않습니다.
+    console.log(arg.length);  // 오류: T에는 .length가 없습니다.
     return arg;
 }
 
    
-
    모든 타입으로 작업하는 대신 이 함수가 .length 프로퍼티를 가진 모든 타입에서 작동하도록 제한을 두고 싶을 것입니다.
    타입에 이 멤버가 있으면 타입을 허용하지만 적어도 이 멤버가 있어야 합니다.
    그렇게 하기 위해서는 T 가 무엇이 될 수 있는지에 대한 제약으로서 요구 사항을 작성해야 합니다.
    
-
    그러기 위해 제약 조건을 설명하는 인터페이스를 만들 것입니다.
    여기에서는 하나의 .length 프로퍼티를 가진 인터페이스를 만들고 이 인터페이스와 extends 키워드를 사용하여 제약조건을 나타냅니다.
    
+
    any와 모든 타입에서 동작하는 대신에, .length 프로퍼티가 있는 any와 모든 타입들에서 작동하는 것으로 제한하고 싶습니다.
+타입이 이 멤버가 있는 한 허용하지만, 최소한 .length 가 있어야 합니다.
+그렇게 하려면 T 가 무엇이 될 수 있는지에 대한 제약 조건을 나열해야 합니다.
    
+
    이를 위해 우리의 제약조건이 명시하는 인터페이스를 만듭니다.
+여기 하나의 프로퍼티 .length를 가진 인터페이스를 생성하였고, 우리의 제약사항을 extends 키워드로 표현한 인터페이스를 이용해 명시합니다:
    
 
    interface Lengthwise {
     length: number;
 }
 
 function loggingIdentity<T extends Lengthwise>(arg: T): T {
-    console.log(arg.length);  // 이제 .length 프로퍼티가 있으므로 더이상 오류가 없습니다.
+    console.log(arg.length);  // 이제 .length 프로퍼티가 있는 것을 알기 때문에 더 이상 오류가 발생하지 않습니다.
     return arg;
 }
 
    
-
    제네릭 함수는 이제 제한되어 있으므로 더이상 모든 타입에서 작동하지 않습니다.
    
-
    loggingIdentity(3);  // 오류, number 는 .length 프로퍼티가 없습니다.
+
    제네릭 함수는 이제 제한되어 있기 때문에 모든 타입에 대해서는 동작하지 않습니다:
    
+
    loggingIdentity(3);  // 오류, number는 .length 프로퍼티가 없습니다.
 
    
-
    대신 모든 필수 프로퍼티가 있는 타입의 값을 전달해야 합니다.
    
+
    대신 필요한 프로퍼티들이 있는 타입의 값을 전달해야 합니다:
    
 
    loggingIdentity({length: 10, value: 3});
 
    
 
    제네릭 제약조건에서 타입 매개변수 사용 (Using Type Parameters in Generic Constraints)
    
-
    다른 타입 매개 변수에 의해 제한되는 타입 매개변수를 선언할 수 있습니다.
    예를 들어 여기서는 이름을 가진 객체의 프로퍼티를 가져오려고 합니다.
    실수로 obj에 존재하지 않는 프로퍼티를 잡아내지 않도록 하고자 합니다.
     그래서 두가지 타입 사이에 제약조건을 적용할 것입니다:
    
+
    다른 타입 매개변수로 제한된 타입 매개변수를 선언할 수 있습니다.
+이름이 있는 객체에서 프로퍼티를 가져오고 싶은 경우를 예로 들어 봅시다.
+실수로 obj에 존재하지 않는 프로퍼티를 가져오지 않도록 하기 위해 두 가지 타입에 제약조건을 두었습니다.
    
 
    function getProperty<T, K extends keyof T>(obj: T, key: K) {
     return obj[key];
 }
 
 let x = { a: 1, b: 2, c: 3, d: 4 };
 
-getProperty(x, "a"); // 오류 없음
-getProperty(x, "m"); // 오류 : 타입 'm'의 인수를 'a' | 'b' | 'c' | 'd' 에 할당 할 수 없습니다.
+getProperty(x, "a"); // 성공
+getProperty(x, "m"); // 오류: 인수의 타입 'm' 은 'a' | 'b' | 'c' | 'd'에 해당되지 않음.
 
    
 
    제네릭에서 클래스 타입 사용 (Using Class Types in Generics)
    
-
    제네릭을 사용하여 TypeSciprt에서 팩토리를 생성할 때 생성자 함수를 사용하여 클래스 타입을 참조해야 합니다.
    
-
    예를 들어
    
+
    제네릭을 사용하는 TypeScript에서 팩토리를 생성할 때 생성자 함수로 클래스 타입을 참조해야 합니다. 예를 들면:
    
 
    function create<T>(c: {new(): T; }): T {
     return new c();
 }
 
    
-
    아래의 고급 예제는 프로토타입 프로퍼티를 사용하여 생성자 함수와 클래스 타입의 인스턴스 사이의 관계를 추론하고 제한합니다.
    
+
    고급 예제에서는 prototype 프로퍼티를 사용하여 생성자 함수와 클래스 타입의 인스턴스 사이의 관계를 유추하고 제한합니다.
    
 
    class BeeKeeper {
     hasMask: boolean;
 }
@@ -906,8 +985,8 @@ 
    return new c();
 }
 
-createInstance(Lion).keeper.nametag;  // 타입 체크!
-createInstance(Bee).keeper.hasMask;   // 타입 체크!
+createInstance(Lion).keeper.nametag;  // 타입검사!
+createInstance(Bee).keeper.hasMask;   // 타입검사!
 
    
 
                                 
@@ -952,7 +1031,7 @@ 
    No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"제네릭","level":"3.6","depth":1,"next":{"title":"열거형","level":"3.7","depth":1,"path":"pages/Enums.md","ref":"pages/Enums.md","articles":[]},"previous":{"title":"함수","level":"3.5","depth":1,"path":"pages/Functions.md","ref":"pages/Functions.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Generics.md","mtime":"2019-06-14T05:32:52.240Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"제네릭","level":"3.6","depth":1,"next":{"title":"열거형","level":"3.7","depth":1,"path":"pages/Enums.md","ref":"pages/Enums.md","articles":[]},"previous":{"title":"함수","level":"3.5","depth":1,"path":"pages/Functions.md","ref":"pages/Functions.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Generics.md","mtime":"2020-04-22T15:29:36.174Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Integrating with Build Tools.html b/pages/Integrating with Build Tools.html
index c0351e31..d3a20197 100644
--- a/pages/Integrating with Build Tools.html	
+++ b/pages/Integrating with Build Tools.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
    • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
  • 
+        
  • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
    • 
+    
+        
  • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
  • 릴리즈 노트
    • 
+        
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
    • 
+    
+
+    
 
     
  • 
 
@@ -911,7 +957,7 @@ 
    No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"빌드 도구와 통합","level":"5.4","depth":1,"next":{"title":"Nightly 빌드","level":"5.5","depth":1,"path":"pages/Nightly Builds.md","ref":"pages/Nightly Builds.md","articles":[]},"previous":{"title":"MSBuild에서의 컴파일러 옵션","level":"5.3","depth":1,"path":"pages/Compiler Options in MSBuild.md","ref":"pages/Compiler Options in MSBuild.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Integrating with Build Tools.md","mtime":"2019-06-14T05:32:52.240Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"빌드 도구와 통합","level":"5.5","depth":1,"next":{"title":"Nightly 빌드","level":"5.6","depth":1,"path":"pages/Nightly Builds.md","ref":"pages/Nightly Builds.md","articles":[]},"previous":{"title":"MSBuild에서의 컴파일러 옵션","level":"5.4","depth":1,"path":"pages/Compiler Options in MSBuild.md","ref":"pages/Compiler Options in MSBuild.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Integrating with Build Tools.md","mtime":"2020-04-22T13:02:03.077Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Interfaces.html b/pages/Interfaces.html
index a60b5837..892e1371 100644
--- a/pages/Interfaces.html
+++ b/pages/Interfaces.html
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
    • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
  • 
+        
  • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
    • 
+    
+        
  • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
  • 릴리즈 노트
    • 
+        
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
    • 
+    
+
+    
 
     
  • 
 
@@ -712,86 +758,98 @@ 
    
                                 
    
                                 
                                 
    소개 (Introduction)
    
-
    TypeScript 의 핵심 원리 중 하나는 값이 가지는 형태 에 초점을 맞추는 타입-체킹을 한다는 것입니다.
    이것은 때때로 "덕 타이핑(duck typing)" 또는 "구조적 하위 유형화(structural subtyping)"라고도 합니다.
    TypeScript 에서는 인터페이스가 이러한 타입의 이름을 지정하는 역할을 하며 코드 내에서 계약을 정의하고 프로젝트 외부에서 코드를 사용하는 계약을 정의하는 강력한 방법입니다.
    
-
    첫번째 인터페이스 (Our First Interface)
    
-
    인터페이스의 작동 방식을 확인하는 가장 쉬운 방법은 간단한 예를 들어 시작하는 것입니다:
    
-
    function printLabel(labelledObj: { label: string }) {
-  console.log(labelledObj.label);
+
    TypeScript의 핵심 원칙 중 하나는 타입 검사가 값의 형태에 초점을 맞추고 있다는 것입니다.
+이를 "덕 타이핑(duck typing)" 혹은 "구조적 서브타이핑 (structural subtyping)"이라고도 합니다.
+TypeScript에서, 인터페이스는 이런 타입들의 이름을 짓는 역할을 하고 코드 안의 계약을 정의하는 것뿐만 아니라 프로젝트 외부에서 사용하는 코드의 계약을 정의하는 강력한 방법입니다.
    
+
    첫 번째 인터페이스 (Our First Interface)
    
+
    어떻게 인터페이스가 동작하는지 확인하는 가장 쉬운 방법은 간단한 예제로 시작하는 것입니다:
    
+
    function printLabel(labeledObj: { label: string }) {
+    console.log(labeledObj.label);
 }
 
-let myObj = { size: 10, label: "Size 10 Object" };
+let myObj = {size: 10, label: "Size 10 Object"};
 printLabel(myObj);
 
    
-
    타입-체커는 printLabel에 대한 호출을 확인합니다.
    PrintLabel 함수에는 객체를 전달하는 데 필요한 단일 매개변수가 있으며 이는 문자열 타입의 label 프로퍼티를 가집니다.
    실제로 객체는 이보다 더 많은 프로퍼티를 가지고 있지만 컴파일러는 필요한 속성이 최소한 있고 필요한 타입과 일치하는지만 검사합니다.
    TypeScript 가 그렇게 관대하지 않은 경우도 있습니다. 이에 대해 좀 더 자세히 다룰 것입니다.
    
-
    이번에도 인터페이스를 사용하여 문자열 타입인 label 프로퍼티를 가져야 한다는 요구 사항을 설명하는 동일한 예제를 다시 작성할 수 있습니다:
    
-
    interface LabelledValue {
-  label: string;
+
    타입 검사는 printLabel 호출을 확인합니다.
+printLabel 함수는 string 타입 label을 갖는 객체를 하나의 매개변수로 가집니다.
+이 객체가 실제로는 더 많은 프로퍼티를 갖고 있지만, 컴파일러는 최소한 필요한 프로퍼티가 있는지와 타입이 잘 맞는지만 검사합니다.
+TypeScript가 관대하지 않은 몇 가지 경우는 나중에 다루겠습니다.
    
+
    이번엔 같은 예제를, 문자열 타입의 프로퍼티 label을 가진 인터페이스로 다시 작성해 보겠습니다:
    
+
    interface LabeledValue {
+    label: string;
 }
 
-function printLabel(labelledObj: LabelledValue) {
-  console.log(labelledObj.label);
+function printLabel(labeledObj: LabeledValue) {
+    console.log(labeledObj.label);
 }
 
-let myObj = { size: 10, label: "Size 10 Object" };
+let myObj = {size: 10, label: "Size 10 Object"};
 printLabel(myObj);
 
    
-
    인터페이스 LabelledValue은 이전 예제의 요구 사항을 설명하는 데 사용할 수 있는 이름입니다.
    여전히 label이라는 문자열 타입의 단일 프로퍼티가 있습니다.
    printLabel에 전달하는 객체가 다른 언어처럼 이 인터페이스를 구현한다고 명시적으로 말할 필요가 없었습니다.
    여기서는 중요한 형태일 뿐입니다. 함수로 전달되는 객체가 나열된 요구 사항을 충족하는 경우 허용됩니다.
    
-
    타입-체커에서는 이러한 프로퍼티가 순서대로 제공될 것을 요구하지 않으며 다만 인터페이스에 필요한 속성이 있고 필요한 타입만 필요하다는 점을 지적하는 것이 중요합니다.
    
+
    LabeledValue 인터페이스는 이전 예제의 요구사항을 똑같이 기술하는 이름으로 사용할 수 있습니다.
+이 인터페이스는 여전히 문자열 타입의 label 프로퍼티 하나를 가진다는 것을 의미합니다.
+다른 언어처럼 printLabel에 전달한 객체가 이 인터페이스를 구현해야 한다고 명시적으로 얘기할 필요는 없습니다.
+여기서 중요한 것은 형태뿐입니다. 함수에 전달된 객체가 나열된 요구 조건을 충족하면, 허용됩니다.
    
+
    타입 검사는 프로퍼티들의 순서를 요구하지 않습니다. 단지 인터페이스가 요구하는 프로퍼티들이 존재하는지와 프로퍼티들이 요구하는 타입을 가졌는지만을 확인합니다.
    
 
    선택적 프로퍼티 (Optional Properties)
    
-
    인터페이스의 모든 프로퍼티가 필수로 필요할 수는 없습니다.
    어떤 것들은 특정한 조건 하에 존재하거나 아예 존재하지 않을 수도 있습니다.
    이러한 선택적 프로퍼티는 프로퍼티 중에서 일부만 채워진 객체를 함수에 전달하는 "옵션 백(option bags)"과 같은 패턴을 생성할 때 많이 사용됩니다.
    
-
    다음은 이 패턴의 예입니다:
    
+
    인터페이스의 모든 프로퍼티가 필요한 것은 아닙니다.
+어떤 조건에서만 존재하거나 아예 없을 수도 있습니다.
+선택적 프로퍼티들은 객체 안의 몇 개의 프로퍼티만 채워 함수에 전달하는 "option bags" 같은 패턴을 만들 때 유용합니다.
    
+
    이 패턴의 예제를 한번 보겠습니다:
    
 
    interface SquareConfig {
-  color?: string;
-  width?: number;
+    color?: string;
+    width?: number;
 }
 
-function createSquare(config: SquareConfig): { color: string; area: number } {
-  let newSquare = { color: "white", area: 100 };
-  if (config.color) {
-    newSquare.color = config.color;
-  }
-  if (config.width) {
-    newSquare.area = config.width * config.width;
-  }
-  return newSquare;
+function createSquare(config: SquareConfig): {color: string; area: number} {
+    let newSquare = {color: "white", area: 100};
+    if (config.color) {
+        newSquare.color = config.color;
+    }
+    if (config.width) {
+        newSquare.area = config.width * config.width;
+    }
+    return newSquare;
 }
 
-let mySquare = createSquare({ color: "black" });
+let mySquare = createSquare({color: "black"});
 
    
-
    선택적 프로퍼티를 가진 인터페이스는 다른 인터페이스와 유사하게 작성되며 선언된 프로퍼티 이름 끝에 ?로 표시됩니다.
    
-
    선택적 프로퍼티의 장점은 사용 가능한 프로퍼티를 설명하는 동시에 인터페이스에 포함되지 않은 프로퍼티의 사용을 방지할 수 있다는 것입니다.
    
-
    예를 들어 createSquare에서 color 프로퍼티의 이름을 잘못 입력하면 다음과 같은 오류 메시지가 표시됩니다:
    
+
    선택적 프로퍼티를 가지는 인터페이스는 다른 인터페이스와 비슷하게 작성되고, 선택적 프로퍼티는 선언에서 프로퍼티 이름 끝에 ?를 붙여 표시합니다.
    
+
    선택적 프로퍼티의 이점은 인터페이스에 속하지 않는 프로퍼티의 사용을 방지하면서, 사용 가능한 속성을 기술하는 것입니다.
+예를 들어, createSquare안의 color 프로퍼티 이름을 잘못 입력하면, 오류 메시지로 알려줍니다:
    
 
    interface SquareConfig {
-  color?: string;
-  width?: number;
+    color?: string;
+    width?: number;
 }
 
 function createSquare(config: SquareConfig): { color: string; area: number } {
-  let newSquare = { color: "white", area: 100 };
-  if (config.color) {
-    // 오류 : 'SquareConfig' 타입에 'clor'프로퍼티가 존재하지 않습니다.
-    newSquare.color = config.clor;
-  }
-  if (config.width) {
-    newSquare.area = config.width * config.width;
-  }
-  return newSquare;
+    let newSquare = {color: "white", area: 100};
+    if (config.clor) {
+        // Error: Property 'clor' does not exist on type 'SquareConfig'
+        newSquare.color = config.clor;
+    }
+    if (config.width) {
+        newSquare.area = config.width * config.width;
+    }
+    return newSquare;
 }
 
-let mySquare = createSquare({ color: "black" });
+let mySquare = createSquare({color: "black"});
 
    
-
    읽기 전용 프로퍼티 (Readonly properties)
    
-
    일부 프로퍼티는 객체를 처음 생성할 때만 수정할 수 있어야 합니다.
    프로퍼티 이름 앞에 readonly을 붙여 넣어 지정할 수 있습니다:
    
+
    읽기전용 프로퍼티 (Readonly properties)
    
+
    일부 프로퍼티들은 객체가 처음 생성될 때만 수정 가능해야합니다.
+프로퍼티 이름 앞에 readonly를 넣어서 이를 지정할 수 있습니다:
    
 
    interface Point {
-  readonly x: number;
-  readonly y: number;
+    readonly x: number;
+    readonly y: number;
 }
 
    
-
    객체 리터럴을 할당하여 Point를 구성 할 수 있습니다. 할당 후 x와 y는 바꿀 수 없습니다.
    
+
    객체 리터럴을 할당하여 Point를 생성합니다.
+할당 후에는 x, y를 수정할 수 없습니다.
    
 
    let p1: Point = { x: 10, y: 20 };
 p1.x = 5; // 오류!
 
    
-
    TypeScript 에는 모든 변형 메서드가 제거된 Array<T>와 동일한 ReadonlyArray<T>타입이 있으므로 생성 후 배열을 변경하지 말아야 합니다.
    
+
    TypeScript에서는 모든 변경 메서드(Mutating Methods)가 제거된 Array<T>와 동일한 ReadonlyArray<T> 타입을 제공합니다. 그래서 생성 후에 배열을 변경하지 않음을 보장할 수 있습니다.
    
 
    let a: number[] = [1, 2, 3, 4];
 let ro: ReadonlyArray<number> = a;
 ro[0] = 12; // 오류!
@@ -799,80 +857,114 @@ 
    ro.length = 100; // 오류!
 a = ro; // 오류!
 
    
-
    코드의 마지막 줄에서 전체 ReadonlyArray를 일반적인 배열로 다시 할당하는 것조차도 불법임을 알 수 있습니다.
    그럼에도 불구하고 타입 단언(assertion)을 통해 오버라이드 할 수 있습니다.
    
+
    예제 마지막 줄에서 ReadonlyArray를 일반 배열에 재할당이 불가능한 것을 확인할 수 있습니다.
+타입 단언(type assertion)으로 오버라이드하는 것은 가능합니다:
    
 
    a = ro as number[];
 
    
 
    readonly vs const
    
-
    readonly 을 사용할지 아니면 const 사용할지 기억할 수 있는 가장 쉬운 방법은 변수에서 사용할지 또는 프로퍼티에서 사용할지를 묻는 것입니다.
    변수는 const를 사용하는 반면 프로퍼티는 readonly를 사용합니다.
    
-
    프로퍼티 초과 검사 (Excess Property Checks)
    
-
    인터페이스를 사용하는 첫 번째 예에서 TypeScript 를 사용하면 { size: number; label: string; }을 { label: string; }으로만 예상하는 항목으로 전달할 수 있습니다.
    또한 선택적 프로퍼티에 대해서 배웠고 그것이 소위 말하는 "옵션 백(option bags)"을 설명할 때 어떻게 유용한지도 배웠습니다.
    
-
    그러나 두 가지를 결합하는 것은 JavaScript 에서 하고 있는 것과 같은 방식으로 자신의 무덤을 파는 것입니다.
    예를 들어 createSquare를 사용한 마지막 예제를 봅시다:
    
+
    readonly와 const 중에 어떤 것을 사용할 지 기억하기 가장 쉬운 방법은 변수와 프로퍼티중 어디에 사용할지 질문해 보는 것입니다.
+변수는 const를 사용하고 프로퍼티는 readonly를 사용합니다
    
+
    초과 프로퍼티 검사 (Excess Property Checks)
    
+
    인터페이스의 첫 번째 예제에서 TypeScript가 { label: string; }을 기대해도 { size: number; label: string; }를 허용해주었습니다. 또한 선택적 프로퍼티를 배우고, 소위 "option bags"을 기술할 때, 유용하다는 것을 배웠습니다.
    
+
    하지만, 그냥 그 둘을 결합하면 에러가 발생할 수 있습니다.
+예를 들어, createSquare를 사용한 마지막 예제를 보겠습니다:
    
 
    interface SquareConfig {
-  color?: string;
-  width?: number;
+    color?: string;
+    width?: number;
 }
 
 function createSquare(config: SquareConfig): { color: string; area: number } {
-  // ...
+    // ...
 }
 
 let mySquare = createSquare({ colour: "red", width: 100 });
 
    
-
    createSquare의 인수는 color가 아닌 colour 입니다. 보통의 JavaScript 에서는 이러한 종류의 작업은 조용히 실패합니다.
    
-
    width 프로퍼티가 호환되고 color 프로퍼티가 없으며 특별하게 color 프로퍼티가 대수롭지 않기 때문에 이 프로그램이 올바른 타입임을 주장할 수 있습니다.
    
-
    그러나 TypeScript 는 이 코드에 버그가 있을 수 있음을 나타냅니다.
    객체 리터럴은 다른 변수에 할당하거나 인수로 전달할 때 특별한 처리를 받아 프로퍼티 초과 검사(Excess Property Checks) 를 거칩니다.
    객체 리터럴에 "대상 타입"에 없는 프로퍼티가 있을 경우 오류가 발생합니다.
    
-
    // 오류 : 'colour'는 'SquareConfig' 타입에서 필요하지 않습니다.
+
    createSquare의 매개변수가 color대신 colour로 전달된 것에 유의하세요.
+이 경우 JavaScript에선 조용히 오류가 발생합니다.
    
+
    width 프로퍼티는 적합하고, color 프로퍼티는 없고, 추가 colour 프로퍼티는 중요하지 않기 때문에, 이 프로그램이 올바르게 작성되었다고 생각할 수 있습니다.
    
+
    하지만, TypeScript는 이 코드에 버그가 있을 수 있다고 생각합니다.
+객체 리터럴은 다른 변수에 할당할 때나 인수로 전달할 때, 특별한 처리를 받고, 초과 프로퍼티 검사 (excess property checking)를 받습니다.
+만약 객체 리터럴이 "대상 타입 (target type)"이 갖고 있지 않은 프로퍼티를 갖고 있으면, 에러가 발생합니다.
    
+
    // error: Object literal may only specify known properties, but 'colour' does not exist in type 'SquareConfig'. Did you mean to write 'color'?
 let mySquare = createSquare({ colour: "red", width: 100 });
 
    
-
    이런 검사을 하는 것은 실제로 정말 간단합니다.
    가장 쉬운 방법은 타입 단언(type assertion)을 사용하는 것입니다:
    
+
    이 검사를 피하는 방법은 정말 간단합니다.
+가장 간단한 방법은 타입 단언을 사용하는 것입니다:
    
 
    let mySquare = createSquare({ width: 100, opacity: 0.5 } as SquareConfig);
 
    
-
    하지만 객체에 특별한 방법으로 사용되는 추가 프로퍼티가 있는 것이 확실한 경우 문자열 인덱스 시그니처(string index signature)을 추가하는 것이 더 좋습니다.
    
-
    SquareConfig가 위의 타입이 포함되는 color 및 width 프로퍼티가 가질 수 있지만 또 다른 속성도 있는 경우에는 다음과 같이 정의할 수 있습니다.
    
+
    하지만 특별한 경우에, 추가 프로퍼티가 있음을 확신한다면, 문자열 인덱스 서명(string index signatuer)을 추가하는 것이 더 나은 방법입니다.
+만약 SquareConfig color와 width 프로퍼티를 위와 같은 타입으로 갖고 있고, 또한 다른 프로퍼티를 가질 수 있다면, 다음과 같이 정의할 수 있습니다.
    
 
    interface SquareConfig {
-  color?: string;
-  width?: number;
-  [propName: string]: any;
+    color?: string;
+    width?: number;
+    [propName: string]: any;
 }
 
    
-
    이후에 인덱스 시그니처(index signatures)에 대해 이야기하겠지만 SquareConfig은 여러 프로퍼티들을 가질 수 있으며 color 또는 width가 아닌 다른 프로퍼티들의 타입은 문제 되지 않습니다.
    
-
    이러한 검사를 하는 마지막 방법 중 하나는 객체를 다른 변수에 할당하는 것입니다: squareOptions은 너무 프로퍼티 초과 검사를 거치지 않기 때문에 컴파일러가 오류를 제공하지 않습니다:
    
+
    나중에 인데스 서명에 대해 좀 더 다룰 것입니다. 하지만 여기서는 SquareConfig가 여러 프로퍼티가 가질 수 있고, 그 프로퍼티들이 color나 width가 아니라면, 그들의 타입은 중요하지 않습니다.
    
+
    이 검사를 피하는 마지막 방법은 놀랍게도 객체를 다른 변수에 할당하는 것입니다.
+squareOptions가 추가 프로퍼티 검사를 받지 않기 때문에, 컴파일러는 에러를 주지 않습니다.
    
 
    let squareOptions = { colour: "red", width: 100 };
 let mySquare = createSquare(squareOptions);
 
    
-
    위와 같은 간단한 코드의 경우에는 이러한 검사를 "회피하는" 시도를 하지 말아야 합니다.
    메서드와 상태를 유지하는 더 복잡한 객체 리터럴의 경우 이러한 기법을 유지하고 싶은 마음이겠지만 대부분의 초과 프로퍼티 오류는 실제로 버그입니다.
    즉 옵션 백(option bags)과 같은 물건에 대해 초과 프로퍼티 검사 문제가 발생하는 경우 타입 선언 중 일부를 수정해야 할 수도 있습니다.
    createSquare에 color 또는 colour 프로퍼티를 모두 포함한 객체를 전달하는 것이 괜찮은 경우 squareConfig의 정의를 수정해야 합니다.
    
+
    squareOptions와 SquareConfig 사이에 공통 프로퍼티가 있는 경우에만 위와 같은 방법을 사용할 수 있습니다.
+이 예제에서는, width가 그 경우입니다. 하지만 만약에 변수가 공통 객체 프로퍼티가 없으면 에러가 납니다. 예를 들어:
    
+
    let squareOptions = { colour: "red" };
+let mySquare = createSquare(squareOptions);
+
    
+
    위처럼 간단한 코드의 경우, 이 검사를 "피하는" 방법을 시도하지 않는 것이 좋습니다.
+메서드가 있고 상태를 가지는 등 더 복잡한 객체 리터럴에서 이 방법을 생각해볼 수 있습니다. 하지만 초과 프로퍼티 에러의 대부분은 실제 버그입니다.
+그 말은, 만약 옵션 백 같은 곳에서 초과 프로퍼티 검사 문제가 발생하면, 타입 정의를 수정해야 할 필요가 있습니다.
+예를 들어, 만약 createSquare에 color나 colour 모두 전달해도 괜찮다면, squareConfig가 이를 반영하도록 정의를 수정해야 합니다.
    
 
    함수 타입 (Function Types)
    
-
    인터페이스는 JavaScript 객체가 취할 수 있는 다양한 형태을 형성할 수 있습니다.
    프로퍼티를 가진 객체를 설명하는 것 외에도 인터페이스는 함수 타입을 형성할 수도 있습니다.
    
-
    인터페이스가 포함된 함수의 타입을 형성하기 위해 인터페이스에 호출 시그니처(call signature)을 제공합니다.
    이것은 매개 변수 목록과 반환 타입만 주어진 함수 선언과 같습니다. 매개 변수 목록의 각 매개 변수에는 이름과 타입이 모두 필요합니다.
    
+
    인터페이스는 JavaScript 객체가 가질 수 있는 넓은 범위의 형태를 기술할 수 있습니다.
+프로퍼티로 객체를 기술하는 것 외에, 인터페이스는 함수 타입을 설명할 수 있습니다.
    
+
    인터페이스로 함수 타입을 기술하기 위해, 인터페이스에 호출 서명 (call signature)를 전달합니다.
+이는 매개변수 목록과 반환 타입만 주어진 함수 선언과 비슷합니다. 각 매개변수는 이름과 타입이 모두 필요합니다.
    
 
    interface SearchFunc {
-  (source: string, subString: string): boolean;
+    (source: string, subString: string): boolean;
 }
 
    
-
    일단 정의되면 다른 인터페이스처럼 이 함수 타입의 인터페이스를 사용할 수 있습니다.
    여기서는 함수 타입의 변수를 생성하고 동일한 타입의 함수 값을 할당하는 방법을 보여줍니다.
    
+
    한번 정의되면, 함수 타입 인터페이스는 다른 인터페이스처럼 사용할 수 있습니다.
+여기서 함수 타입의 변수를 만들고, 같은 타입의 함수 값으로 할당하는 방법을 보여줍니다.
    
 
    let mySearch: SearchFunc;
 mySearch = function(source: string, subString: string) {
-  let result = source.search(subString);
-  return result > -1;
-};
+    let result = source.search(subString);
+    return result > -1;
+}
 
    
-
    함수 타입의 타입을 검사할 때 매개 변수의 이름이 일치할 필요는 없습니다.
    예를 들어 다음과 같은 예를 작성할 수 있습니다:
    
+
    올바른 함수 타입 검사를 위해, 매개변수의 이름이 같을 필요는 없습니다.
+예를 들어, 위의 예제를 아래와 같이 쓸 수 있습니다:
    
 
    let mySearch: SearchFunc;
 mySearch = function(src: string, sub: string): boolean {
-  let result = src.search(sub);
-  return result > -1;
-};
+    let result = src.search(sub);
+    return result > -1;
+}
+
    
+
    함수 매개변수들은 같은 위치에 대응되는 매개변수끼리 한번에 하나씩 검사합니다.
+만약 타입을 전혀 지정하지 않고 싶다면, SearchFunc 타입의 변수로 직접 함수 값이 할당되었기 때문에 TypeScript의 문맥상 타이핑 (contextual typing)이 인수 타입을 추론할 수 있습니다.
+이 예제에서, 함수 표현의 반환 타입이 반환하는 값으로 추론됩니다. (여기서는 false와 true)
    
+
    let mySearch: SearchFunc;
+mySearch = function(src, sub) {
+    let result = src.search(sub);
+    return result > -1;
+}
 
    
-
    함수 매개 변수는 하나씩 검사되며 각 해당 파라미터 위치의 타입을 서로 비교하며 검사합니다.
    타입을 지정하지 않으려는 경우 함수 값이 SearchFunc 타입의 변수에 직접 지정되므로 TypeScript 의 컨텍스트 타입(contextual typing)에 따라 인수 타입을 추론할 수 있습니다.
    또한 여기서 함수 표현식의 반환 타입은 반환되는 값에 의해서도 암시적으로 나타납니다(여기서는 true와 false)
    함수 표현식이 숫자나 문자열을 반환하는 경우 타입-체커가 반환 타입이 SearchFunc 인터페이스에 설명된 반환 타입과 일치하지 않는다는 경고했을 것입니다
    
+
    함수 표현식이 숫자 나 문자열을 반환했다면, 타입 검사는 반환 타입이 SearchFunc 인터페이스에 정의된 반환 타입과 일치하지 않는다는 에러를 발생시킵니다.
    
 
    let mySearch: SearchFunc;
+
+// error: Type '(src: string, sub: string) => string' is not assignable to type 'SearchFunc'.
+// Type 'string' is not assignable to type 'boolean'.
 mySearch = function(src, sub) {
   let result = src.search(sub);
-  return result > -1;
+  return "string";
 };
 
    
-
    인덱싱 가능 타입(Indexable Types)
    
-
    함수 타입을 설명하기 위해 인터페이스를 사용하는 방법과 마찬가지로 a[10] 또는 ageMap["daniel"]처럼 "인덱스"를 생성할 수 있는 타입을 만들 수도 있습니다.
    인덱싱 가능 타입에는 객체로 인덱싱 하는 데 사용할 수 있는 타입과 인덱싱 할 때 해당 반환 타입을 설명하는 인덱스 시그니처(index signature) 이 있습니다.
    예를 들어 보겠습니다.
    
+
    인덱서블 타입 (Indexable Types)
    
+
    인터페이스로 함수 타입을 설명하는 방법과 유사하게, a[10] 이나 ageMap["daniel"] 처럼 타입을 "인덱스로" 기술할 수 있습니다.
+인덱서블 타입은 인덱싱 할때 해당 반환 유형과 함께 객체를 인덱싱하는 데 사용할 수 있는 타입을 기술하는 인덱스 시그니처 (index signature)를 가지고 있습니다.
+예제를 보겠습니다:
    
 
    interface StringArray {
-  [index: number]: string;
+    [index: number]: string;
 }
 
 let myArray: StringArray;
@@ -880,154 +972,186 @@ 
    let myStr: string = myArray[0];
 
    
-
    위에서 우리는 인덱스 시그니처(index signature)을 가진 String Array 인터페이스를 가지고 있습니다.
    이 인덱스 시그니처은 StringArray이 number로 인덱싱 될 때 string을 반환한다는 것을 나타냅니다.
    
-
    지원되는 인덱스 시그니처에는 문자열과 숫자의 두 가지 타입이 있습니다.
    두 가지 타입의 인덱서(indexer)를 모두 지원할 수 있지만 숫자(numeric) 인덱서에서 반환되는 타입은 문자열(string) 인덱서에서 반환된 타입의 하위 타입이어야 합니다.
    왜냐하면 number로 인덱싱을 생성하는 시점에 JavaScript 가 객체로 인덱싱하기 전에 string으로 변환하기 때문입니다.
    즉 100 (number)로 인덱싱하는 것은 "100" (string)으로 인덱싱하는 것과 동일하므로 두 가지 모두 일관성이 있어야 합니다.
    
+
    위에서 인덱스 서명이 있는 StringArray 인터페이스가 있습니다.
+이 인덱스 서명은 StringArray가 number로 색인화(indexed)되면 string을 반환할 것을 나타냅니다.
    
+
    인덱스 서명을 지원하는 타입에는 두 가지가 있습니다: 문자열과 숫자.
    
+
    두 타입의 인덱서(indexer)를 모두 지원하는 것은 가능하지만, 숫자 인덱서에서 반환된 타입은 반드시 문자열 인덱서에서 반환된 타입의 하위 타입(subtype)이어야 합니다.
+이 이유는 number로 인덱싱 할 때, JavaScript는 실제로 객체를 인덱싱하기 전에 string으로 변환하기 때문입니다.
+즉, 100 (number)로 인덱싱하는 것은 "100" (string)로 인덱싱하는 것과 같기 때문에, 서로 일관성 있어야 합니다.
    
 
    class Animal {
-  name: string;
+    name: string;
 }
 class Dog extends Animal {
-  breed: string;
+    breed: string;
 }
 
-// 오류: numeric과 string으로 인덱싱하면 완전히 다른 타입의 Animal을 얻을 수 있습니다!
+// 오류: 숫자형 문자열로 인덱싱을 하면 완전히 다른 타입의 Animal을 얻게 될 것입니다!
 interface NotOkay {
-  [x: number]: Animal;
-  [x: string]: Dog;
+    [x: number]: Animal;
+    [x: string]: Dog;
 }
 
    
-
    문자열 인덱스 시그니처(index signatures)이 "사전(dictionary)" 패턴을 만드는 강력한 방법이지만 모든 프로퍼티가 반환 타입과 일치하도록 강요합니다.
    문자열 인덱스의 obj.property가 obj["property"]으로도 사용할 수 있다고 선언하기 때문입니다.
    다음 예에서는 name의 타입이 문자열 인덱스의 타입과 일치하지 않으며 타입-체커에서 오류를 표시합니다
    
+
    문자열 인덱스 시그니처는 "사전" 패턴을 기술하는데 강력한 방법이지만, 모든 프로퍼티들이 반환 타입과 일치하도록 강제합니다.
+문자열 인덱스가 obj.property가 obj["property"]로도 이용 가능함을 알려주기 때문입니다.
+다음 예제에서, name의 타입은 문자열 인덱스 타입과 일치하지 않고, 타입 검사는 에러를 발생시킵니다.
    
 
    interface NumberDictionary {
-  [index: string]: number;
-  length: number; // 좋아요, length는 number입니다.
-  name: string; // 오류, 'name'의 타입이 인덱서의 하위 타입이 아닙니다.
+    [index: string]: number;
+    length: number;    // 성공, length는 숫자입니다
+    name: string;      // 오류, `name`의 타입은 인덱서의 하위타입이 아닙니다
+}
+
    
+
    하지만, 인덱스 시그니처가 프로퍼티 타입들의 합집합이라면 다른 타입의 프로퍼티들도 허용할 수 있습니다:
    
+
    interface NumberOrStringDictionary {
+    [index: string]: number | string;
+    length: number;    // 성공, length는 숫자입니다
+    name: string;      // 성공, name은 문자열입니다
 }
 
    
-
    마지막으로 인덱스에 할당되지 않도록 인덱스 시그니처(index signatures)을 읽기 전용(readonly)으로 만들 수 있습니다:
    
+
    마지막으로, 인덱스의 할당을 막기 위해 인덱스 시그니처를 읽기 전용으로 만들 수 있습니다:
    
 
    interface ReadonlyStringArray {
-  readonly [index: number]: string;
+    readonly [index: number]: string;
 }
 let myArray: ReadonlyStringArray = ["Alice", "Bob"];
 myArray[2] = "Mallory"; // 오류!
 
    
-
    인덱스 시그니처이 읽기 전용이므로 myArray[2]를 설정할 수 없습니다.
    
+
    인덱스 시그니처가 읽기 전용이기 때문에 myArray[2]의 값을 할당할 수 없습니다.
    
 
    클래스 타입 (Class Types)
    
-
    인터페이스 구현 (Implementing an interface)
    
-
    C# 및 Java 와 같은 언어로 인터페이스를 사용하는 가장 일반적인 방법 중 하나로 클래스가 특정 계약을 충족하도록 명시적인 강제가 TypeScript 에서도 가능하다는 것입니다.
    
+
    인터페이스 구현하기 (Implementing an interface)
    
+
    클래스가 특정 계약(contract)을 충족시키도록 명시적으로 강제하는 C#과 Java와 같은 언어에서 인터페이스를 사용하는 가장 일반적인 방법은 TypeScript에서도 가능합니다.
    
 
    interface ClockInterface {
-  currentTime: Date;
+    currentTime: Date;
 }
 
 class Clock implements ClockInterface {
-  currentTime: Date;
-  constructor(h: number, m: number) {}
+    currentTime: Date = new Date();
+    constructor(h: number, m: number) { }
 }
 
    
-
    또한 아래의 예제에서 setTime과 마찬가지로 클래스에 구현된 인터페이스의 메서드를 만들 수도 있습니다.
    
+
    아래 예제의 setTime 처럼 클래스에 구현된 메서드를 인터페이스 안에서도 기술할 수 있습니다.
    
 
    interface ClockInterface {
-  currentTime: Date;
-  setTime(d: Date);
+    currentTime: Date;
+    setTime(d: Date): void;
 }
 
 class Clock implements ClockInterface {
-  currentTime: Date;
-  setTime(d: Date) {
-    this.currentTime = d;
-  }
-  constructor(h: number, m: number) {}
+    currentTime: Date = new Date();
+    setTime(d: Date) {
+        this.currentTime = d;
+    }
+    constructor(h: number, m: number) { }
 }
 
    
-
    인터페이스는 public 측면과 private 측면이 아닌 public 측면의 class 를 만듭니다.
    클래스를 사용하여 클래스 인스턴스의 private 측에 특정 타입이 있는지 검사하는 것은 금지되어 있습니다.
    
-
    클래스의 스태틱과 인스턴스의 차이점(Difference between the static and instance sides of classes)
    
-
    클래스와 인터페이스로 작업할 때 클래스에 두 가지 타입이 있음을 명심하세요: 스태틱 측면의 타입과 인스턴스 측면의 타입
    construct signature 으로 인터페이스를 만들고 이 인터페이스를 구현하는 클래스를 생성하려고 하면 오류가 발생할 수 있습니다:
    
+
    인터페이스는 클래스의 public과 private 모두보다는, public을 기술합니다.
+그래서 클래스 인스턴스의 private에서는 특정 타입이 있는지 검사할 수 없습니다.
    
+
    클래스의 스태틱과 인스턴스의 차이점 (Difference between the static and instance sides of classes)
    
+
    클래스와 인터페이스를 다룰 때, 클래스는 두 가지 타입을 가진다는 것을 기억하는 게 좋습니다: 스태틱 타입과 인스턴스 타입입니다.
+생성 시그니처 (construct signature)로 인터페이스를 생성하고, 클래스를 생성하려고 한다면, 인터페이스를 implements 할 때, 에러가 발생하는 것을 확인할 수 있을 겁니다:
    
 
    interface ClockConstructor {
-  new (hour: number, minute: number);
+    new (hour: number, minute: number);
 }
 
 class Clock implements ClockConstructor {
-  currentTime: Date;
-  constructor(h: number, m: number) {}
+    currentTime: Date;
+    constructor(h: number, m: number) { }
 }
 
    
-
    왜냐하면 클래스가 인터페이스를 구현할 때 클래스의 인스턴스 측면만 검사되기 때문입니다.
    생성자는 정적인 측면이기 때문에 이 검사에 포함되지 않습니다.
    
-
    대신 클래스의 정적인 측면에서 직접 작업해야 합니다.
    이 예제에서는 생성자를 위한 ClockConstructor와 인스턴스 메서드를 위한 ClockInterface라는 두 개의 인터페이스를 정의합니다.
    편의상 전달된 타입의 인스턴스를 생성하는 createClock 생성자 함수를 정의합니다.
    
+
    클래스가 인터페이스를 implements 할 때, 클래스의 인스턴스만 검사하기 때문입니다.
+생성자가 스태틱이기 때문에, 이 검사에 포함되지 않습니다.
    
+
    대신에, 클래스의 스태틱 부분을 직접적으로 다룰 필요가 있습니다.
+이번 예제에서, ClockConstructor는 생성자를 정의하고, ClockInterface는 인스턴스 메서드를 정의하는 두 인터페이스를 정의합니다.
+그리고, 편의를 위해, 전달된 타입의 인스턴스를 생성하는 createClock 생성자 함수를 정의합니다:
    
 
    interface ClockConstructor {
-  new (hour: number, minute: number): ClockInterface;
+    new (hour: number, minute: number): ClockInterface;
 }
 interface ClockInterface {
-  tick();
+    tick(): void;
 }
 
-function createClock(
-  ctor: ClockConstructor,
-  hour: number,
-  minute: number
-): ClockInterface {
-  return new ctor(hour, minute);
+function createClock(ctor: ClockConstructor, hour: number, minute: number): ClockInterface {
+    return new ctor(hour, minute);
 }
 
 class DigitalClock implements ClockInterface {
-  constructor(h: number, m: number) {}
-  tick() {
-    console.log("beep beep");
-  }
+    constructor(h: number, m: number) { }
+    tick() {
+        console.log("beep beep");
+    }
 }
 class AnalogClock implements ClockInterface {
-  constructor(h: number, m: number) {}
-  tick() {
-    console.log("tick tock");
-  }
+    constructor(h: number, m: number) { }
+    tick() {
+        console.log("tick tock");
+    }
 }
 
 let digital = createClock(DigitalClock, 12, 17);
 let analog = createClock(AnalogClock, 7, 32);
 
    
-
    createClock의 첫 번째 매개 변수는 createClock(AnalogClock, 7, 32)에 ClockConstructor 타입이므로 AnalogClock이 올바른 생성자 시그니처(constructor signature)을 가지고 있는지 확인합니다.
    
-
    인터페이스 확장 (Extending Interfaces)
    
-
    클래스처럼 인터페이스도 서로를 확장할 수 있습니다.
    이렇게 하면 한 인터페이스의 멤버를 다른 인터페이스로 복사할 수 있으므로 인터페이스를 재사용 가능한 컴포넌트로 분리하는 방법을 더 유연하게 할 수 있습니다.
    
+
    createClock의 첫 번째 매개변수는 createClock(AnalogClock, 7, 32)안에 ClockConstructor 타입이므로, AnalogClock이 올바른 생성자 시그니처를 갖고 있는지 검사합니다.
    
+
    또 다른 쉬운 방법은 클래스 표현을 사용하는 것입니다.
    
+
    interface ClockConstructor {
+  new (hour: number, minute: number);
+}
+
+interface ClockInterface {
+  tick();
+}
+
+const Clock: ClockConstructor = class Clock implements ClockInterface {
+  constructor(h: number, m: number) {}
+  tick() {
+      console.log("beep beep");
+  }
+}
+
    
+
    인터페이스 확장하기 (Extending Interfaces)
    
+
    클래스처럼, 인터페이스들도 확장(extend)이 가능합니다.
+이는 한 인터페이스의 멤버를 다른 인터페이스에 복사하는 것을 가능하게 해주는데, 인터페이스를 재사용성 높은 컴포넌트로 쪼갤 때, 유연함을 제공해줍니다.
    
 
    interface Shape {
-  color: string;
+    color: string;
 }
 
 interface Square extends Shape {
-  sideLength: number;
+    sideLength: number;
 }
 
-let square = <Square>{};
+let square = {} as Square;
 square.color = "blue";
 square.sideLength = 10;
 
    
-
    여러 인터페이스를 확장하여 모든 인터페이스를 결합하여 만들 수 있습니다.
    
+
    인터페이스는 여러 인터페이스를 확장할 수 있어, 모든 인터페이스의 조합을 만들어낼 수 있습니다.
    
 
    interface Shape {
-  color: string;
+    color: string;
 }
 
 interface PenStroke {
-  penWidth: number;
+    penWidth: number;
 }
 
 interface Square extends Shape, PenStroke {
-  sideLength: number;
+    sideLength: number;
 }
 
-let square = <Square>{};
+let square = {} as Square;
 square.color = "blue";
 square.sideLength = 10;
 square.penWidth = 5.0;
 
    
 
    하이브리드 타입 (Hybrid Types)
    
-
    이전에 언급했듯이 인터페이스는 실제 JavaScript 에서 제공되는 풍부한 타입을 만들 수 있습니다.
    JavaScript 의 동적이고 유연한 특성으로 인해 위에 설명된 몇 가지 타입의 조합으로 작동하는 객체를 종종 볼 수 있습니다.
    
-
    이러한 예로는 다음과 같이 추가 프로퍼티로 함수와 객체 역할을 모두 하는 객체가 있습니다:
    
+
    일찍이 언급했듯이, 인터페이스는 실제 JavaScript 세계에 존재하는 다양한 타입들을 기술할 수 있습니다.
+JavaScript의 동적이고 유연한 특성 때문에, 위에서 설명했던 몇몇 타입의 조합으로 동작하는 객체를 가끔 마주할 수 있습니다.
    
+
    그러한 예제 중 하나는 추가적인 프로퍼티와 함께, 함수와 객체 역할 모두 수행하는 객체입니다:
    
 
    interface Counter {
-  (start: number): string;
-  interval: number;
-  reset(): void;
+    (start: number): string;
+    interval: number;
+    reset(): void;
 }
 
 function getCounter(): Counter {
-  let counter = <Counter>function(start: number) {};
-  counter.interval = 123;
-  counter.reset = function() {};
-  return counter;
+    let counter = (function (start: number) { }) as Counter;
+    counter.interval = 123;
+    counter.reset = function () { };
+    return counter;
 }
 
 let c = getCounter();
@@ -1035,36 +1159,47 @@ 
    
 c.reset();
 c.interval = 5.0;
 
    
-
    써드-파티 JavaScript 와 상호 작용할 때 타입의 형태를 완전히 형성하려면 위와 같은 패턴을 사용해야 할 수 있습니다.
    
-
    인터페이스 확장 클래스 (Interfaces Extending Classes)
    
-
    인터페이스 타입이 클래스 타입을 확장하면 해당 클래스의 멤버들을 상속하지만 구현을 상속하지는 않습니다.
    이는 마치 인터페이스가 구현을 제공하지 않고 클래스의 모든 멤버를 선언한 것과 같습니다.
    인터페이스는 기본 클래스의 private 및 protected 멤버조차도 상속합니다.
    즉 private 또는 protected 멤버가 있는 클래스를 확장하는 인터페이스를 생성하면 해당 인터페이스 타입은 해당 클래스 또는 해당 클래스의 서브 클래스에서만 구현할 수 있습니다.
    
-
    이는 상속 계층이 크지만 특정 프로퍼티를 가진 서브 클래스에서만 코드가 작동하도록 지정하려는 경우에 유용합니다.
    서브 클래스는 기본 클래스에서 상속받는 것 외에는 관련이 없습니다.
    
-
    예를 들어:
    
+
    써드파티 (3rd-party) JavaScript와 상호작용할 때, 타입의 형태를 완전히 기술하기 위해 위와 같은 패턴을 사용해야할 수도 있습니다.
    
+
    클래스를 확장한 인터페이스 (Interfaces Extending Classes)
    
+
    인터페이스 타입이 클래스 타입을 확장하면, 클래스의 멤버는 상속받지만 구현은 상속받지 않습니다.
+이것은 인터페이스가 구현을 제공하지 않고, 클래스의 멤버 모두를 선언한 것과 마찬가지입니다.
+인터페이스는 심지어 기초 클래스의 private과 protected 멤버도 상속받습니다.
+이것은 인터페이스가 private 혹은 protected 멤버를 포함한 클래스를 확장할 수 있다는 뜻이고, 인터페이스 타입은 그 클래스나 하위클래스에 의해서만 구현될 수 있습니다.
    
+
    이는 거대한 상속계층을 가지고 있을 때 유용하지만, 특정 프로퍼티를 가진 하위클래스에서만 코드가 동작하도록 지정하는데도 유용합니다.
+하위클래스는 기초클래스에서 상속하는 것 외에는 관련이 있을 필요가 없습니다.
+예를 들어:
    
 
    class Control {
-  private state: any;
+    private state: any;
 }
 
 interface SelectableControl extends Control {
-  select(): void;
+    select(): void;
 }
 
 class Button extends Control implements SelectableControl {
-  select() {}
+    select() { }
 }
 
 class TextBox extends Control {
-  select() {}
+    select() { }
 }
 
-// 오류: 'Image' 타입의 'state' 프로퍼티가 없습니다.
+// Error: Property 'state' is missing in type 'Image'.
 class Image implements SelectableControl {
-  select() {}
+    private state: any;
+    select() { }
 }
 
-class Location {}
+class Location {
+
+}
 
    
-
    위의 예제에서 SelectableControl에는 Private state 프로퍼티를 포함한 Control의 모든 멤버가 포함되어 있습니다.
    state는 private 멤버이기 때문에 Control의 자식만 SelectableControl을 구현할 수 있습니다.
    왜냐하면 Control의 자식들만이 같은 선언에서 시작된 state private 멤버를 가지기 때문입니다.
    이것은 private 멤버들이 호환 가능해야 합니다.
    
-
    Control 클래스 내에서 SelectableControl의 인스턴스를 통해 state private 멤버에 접근할 수 있습니다.
    실제로 SelectableControl은 알려진 대로 select 메서드를 가진 Control과 같은 역할을 합니다.
    Button과 TextBox 클래스는 SelectableControl의 하위 타입입니다
    (왜냐하면 둘 다 Control을 상속받으며 select 메서드를 가지기 때문입니다).
    그러나 Image 클래스와 Location 클래스는 그렇지 않습니다.
    
+
    위 예제에서, SelectableControl은 private state 프로퍼티를 포함하여, Control의 모든 멤버를 가지고 있습니다.
+state는 private 멤버이기 때문에, SelectableControl를 구현하는 것은 Control의 자식에게만 가능합니다.
+Control의 자식만 같은 선언에서 유래된 state private 멤버를 가질수 있기 때문이고, private 멤버들이 호환되기 위해 필요합니다.
    
+
    Control 클래스 안에서 SelectableControl의 인스턴스를 통해서 state private 멤버에 접근할 수 있습니다.
+SelectableControl은 select 메서드를 가진 Control과 같은 역할을 합니다.
+Button과 TextBox 클래스들은 SelectableControl의 하위타입이지만 (Control을 상속받고, select 메서드를 가지기 때문에), Image와 Location 클래스는 아닙니다.
    
 
                                 
                                 
    
@@ -1108,7 +1243,7 @@ 
    No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"인터페이스","level":"3.3","depth":1,"next":{"title":"클래스","level":"3.4","depth":1,"path":"pages/Classes.md","ref":"pages/Classes.md","articles":[]},"previous":{"title":"변수 선언","level":"3.2","depth":1,"path":"pages/Variable Declarations.md","ref":"pages/Variable Declarations.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Interfaces.md","mtime":"2019-06-14T05:32:52.242Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"인터페이스","level":"3.3","depth":1,"next":{"title":"클래스","level":"3.4","depth":1,"path":"pages/Classes.md","ref":"pages/Classes.md","articles":[]},"previous":{"title":"변수 선언","level":"3.2","depth":1,"path":"pages/Variable Declarations.md","ref":"pages/Variable Declarations.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Interfaces.md","mtime":"2020-04-22T15:29:36.174Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Iterators and Generators.html b/pages/Iterators and Generators.html
index 91bb2949..2ab5bc7d 100644
--- a/pages/Iterators and Generators.html	
+++ b/pages/Iterators and Generators.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
    • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
  • 
+        
  • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
    • 
+    
+        
  • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
  • 릴리즈 노트
    • 
+        
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
    • 
+    
+
+    
 
     
  • 
 
@@ -712,62 +758,63 @@ 
    
                                 
    
                                 
                                 
    이터러블 (Iterables)
    
-
    Symbol.iterator 프로퍼티에 대한 구현을 하고 있는 객체는 iterable로 간주됩니다.
    Array, Map, Set, String, Int32Array, Uint32Array 등과 같은 몇몇 내장 타입은 이미 구현된 Symbol.iterator 프로퍼티를 가지고 있습니다.
    
-
    객체의 Symbol.iterator 함수는 반복할 값 목록을 반환하는 것을 담당한다.
    
-
    for..of 문 (statements)
    
-
    for..of는 반복 가능한 객체에 대해 반복하며 객체에 대해 Symbol.iterator 프로퍼티를 호출합니다.
    
-
    다음은 배열의 간단한 for..of 루프입니다:
    
+
    객체가 Symbol.iterator프로퍼티에 대한 구현을 가지고 있다면 이터러블로 간주합니다.
+Array, Map, Set, String, Int32Array, Uint32Array 등과 같은 일부 내장 타입에는 이미 Symbol.iterator 프로퍼티가 구현되어 있습니다.
+객체의 Symbol.iterator 함수는 반복할 값 목록을 반환합니다.
    
+
    for..of 문
    
+
    for..of는 객체의 Symbol.iterator 프로퍼티를 호출하여, 이터러블 객체를 반복합니다.
+다음은 배열의 간단한 for..of 루프입니다:
    
 
    let someArray = [1, "string", false];
 
-for (let entry of someArray) {
-    console.log(entry); // 1, "string", false
+for (let entry of someArray)
+ console.log(entry); // 1, "string", false
 }
 
    
-
    for..of vs. for..in 문 (statements)
    
-
    for..of와 for..in 모두 리스트를 반복합니다.
    반복되는 값은 다르지만, for..in은 반복되는 객체의 키 를 반환하는 반면 for..of는 반복되는 객체의 숫자(numeric) 프로퍼티의 값 을 반환합니다.
    
-
    다음은 이러한 차이를 보여 주는 예제입니다:
    
+
    for..of vs. for..in 문
    
+
    for..of 및 for..in 문 모두 목록을 반복합니다; 반복되는 값은 다르지만, for..in은 반복되는 객체의 키 목록을 반환하고, 반면에 for..of는 반복되는 객체의 숫자 프로퍼티 값 목록을 반환합니다.
    
+
    다음은 이러한 차이점을 보여주는 예입니다.
    
 
    let list = [4, 5, 6];
 
-for (let i in list) {
-   console.log(i); // "0", "1", "2",
+for (let i in list){
+ console.log(i); // "0", "1", "2"
 }
 
-for (let i of list) {
-   console.log(i); // "4", "5", "6"
+for (let i of list){
+ console.log(i); // "4", "5", "6"
 }
 
    
-
    또 다른 차이점은 for..in은 어떠한 객체에서도 작동한다는 것입니다.
    이 객체의 프로퍼티를 검사하는 방법으로 사용됩니다.
    한편 for..of는 주로 반복 가능한 객체의 값에 관심이 있습니다.  
    
-
    Map과 Set 같은 내장객체는 저장된 값에 접근할 수 있게 해 주는 는Symbol.iterator 프로퍼티를 구현합니다.
    
+
    또 다른 차이점은 for..in은 모든 객체에서 작동한다는 것입니다; 객체의 프로퍼티를 검사하는 방법으로 사용됩니다.
+반면에 for..of는 이터러블 객체의 값에 주로 관심이 있습니다. Map 및 Set과 같은 내장 객체는 저장된 값에 접근할 수 있는 Symbol.iterator 프로퍼티를 구현합니다.
    
 
    let pets = new Set(["Cat", "Dog", "Hamster"]);
 pets["species"] = "mammals";
 
-for (let pet in pets) {
-   console.log(pet); // "species"
+for (let pet in pets){
+ console.log(pet); // "species"
 }
 
-for (let pet of pets) {
-    console.log(pet); // "Cat", "Dog", "Hamster"
+for (let pet of pets){
+ console.log(pet); // "Cat", "Dog", "Hamster"
 }
 
    
-
    코드 생성
    
-
    ES3와 ES5 대상 (Targeting ES5 and ES3)
    
-
    ES5 또는 ES3를 대상으로 할 때 반복자는 Array 타입의 값에만 사용할 수 있습니다.
    
-
    컴파일러는 for..of 루프를 위한 간단한 for 루프를 생성할 것입니다.
    
-
    예를 들어 :
    
+
    코드 생성 (Code generation)
    
+
    ES5 및 ES3 타게팅 (Targeting ES5 and ES3)
    
+
    ES5 또는 ES3-호환 엔진을 대상으로 하는 경우, 반복자는 Array 유형의 값만 허용합니다.
+이런 배열이 아닌 값이 Symbol.iterator 프로퍼티를 구현하더라도 배열이 아닌 값에서 for..of 루프를 사용하면 오류가 발생합니다.
    
+
    컴파일러는 for..of 루프에 대한 간단한 for 루프를 생성합니다, 예를 들면:
    
 
    let numbers = [1, 2, 3];
-for (let num of numbers) {
-    console.log(num);
+for (let num of numbers){
+ console.log(num);
 }
 
    
-
    다음과 같이 생성됩니다 :
    
-
    var numbers = [1, 2, 3];
-for (var _i = 0; _i < numbers.length; _i++) {
-    var num = numbers[_i];
-    console.log(num);
+
    는 다음과 같이 생성합니다:
    
+
    var numbers = [1, 2, 3];
+for (var _i = 0; _i < numbers.length; _i++){
+ var num = numbers[_i];
+ console.log(num);
 }
 
    
-
    ECMAScript 2015 이상 대상 (Targeting ECMAScript 2015 and higher)
    
-
    ECMAScipt 2015 호환 엔진을 대상으로 할 때 컴파일러는 엔진에서 내장 반복자 구현을 대상으로 for..of 루프를 생성합니다.
    
+
    ECMAScript 2015 및 상위 버전 타케팅 (Targeting ECMAScript 2015 and higher)
    
+
    ECMAScipt 2015-호환 엔진을 타케팅하는 경우, 컴파일러는 엔진의 내장 반복자 구현을 대상으로 하는 for..of 루프를 생성합니다.
    
 
                                 
                                 
    
@@ -811,7 +858,7 @@ 
    No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"이터레이터와 제네레이터","level":"3.12","depth":1,"next":{"title":"모듈","level":"3.13","depth":1,"path":"pages/Modules.md","ref":"pages/Modules.md","articles":[]},"previous":{"title":"심볼","level":"3.11","depth":1,"path":"pages/Symbols.md","ref":"pages/Symbols.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Iterators and Generators.md","mtime":"2019-06-14T05:32:52.242Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"이터레이터와 제네레이터","level":"3.12","depth":1,"next":{"title":"모듈","level":"3.13","depth":1,"path":"pages/Modules.md","ref":"pages/Modules.md","articles":[]},"previous":{"title":"심볼","level":"3.11","depth":1,"path":"pages/Symbols.md","ref":"pages/Symbols.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Iterators and Generators.md","mtime":"2020-04-22T15:29:36.175Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/JSX.html b/pages/JSX.html
index d44d736c..bb92dcc9 100644
--- a/pages/JSX.html
+++ b/pages/JSX.html
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
    • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
  • 
+        
  • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
    • 
+    
+        
  • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
  • 릴리즈 노트
    • 
+        
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
    • 
+    
+
+    
 
     
  • 
 
@@ -711,104 +757,143 @@ 
    
     
                                 
    
                                 
-                                
    소개
    
-
    JSX는 XML 같은 구문이  포함 가능합니다.
    의미는 구현에 따라 다르지만 유효한 JavaScript로 변형되어야 합니다.
    JSX는 React에서 인기를 얻었으나 이후 다른 애플리케이션도 볼 수 있습니다.
    TypeScript는 JSX를 직접 JavaScript에 포함, 타입 검사 및 컴파일할 수 있도록 지원합니다.
    
-
    기본 사용 방법
    
-
    JSX를 사용하려면 두 가지 작업을 해야 합니다.
    
+                                
    목차 (Table of contents)
    
+
    소개 (Introduction)
    
+
    기본 사용법 (Basic usage)
    
+
    as 연산자 (The as operator)
    
+
    타입 검사 (Type Checking)
    
+
+
    JSX 결과 타입 (The JSX result type)
    
+
    표현식 포함하기 (Embedding Expressions)
    
+
    리액트와 통합하기 (React integration)
    
+
    팩토리 함수 (Factory Functions)
    
+
    소개 (Introduction)
    
+
    ↥ 위로
    
+
    JSX는 내장형 XML 같은 구문입니다.
+변환의 의미는 구현에 따라 다르지만 유효한 JavaScript로 변환되어야 합니다.
+JSX는 React로 큰 인기를 얻었지만, 이후 다른 구현도 등장했습니다.
+TypeScript는 임베딩, 타입 검사, JSX를 JavaScript로 직접 컴파일하는 것을 지원합니다.
    
+
    기본 사용법 (Basic usage)
    
+
    ↥ 위로
    
+
    JSX를 사용하려면 다음 두 가지 작업을 해야 합니다.
    
 
      
-
    1. 파일의 이름을 .tsx 확장자로 지정하세요
      2. 
-
    2. jsx 옵션을 활성화하세요
      3. 
+
    3. 파일 이름을 .tsx 확장자로 지정합니다.
      4. 
+
    4. jsx 옵션을 활성화합니다.
      5. 
 
    
-
    TypeScript에는 세 가지 JSX 모드가 있습니다: preserve, react, 그리고 react-native.
    이 모드는 방출 단계에만 영향을 미칩니다 - 타입 검사에는 영향받지 않습니다.
    preserve 모드는 다른 변환 단계 (예: Babel)에서 더 사용되도록 출력의 일부로 JSX를 계속 유지합니다.
    추가적으로 출력에는 .jsx 파일 확장자가 지정되어 있습니다.
    react 모드는 React.createElement를 방출하고 사용하기 전에 JSX 변환을 거칠 필요가 없으며 출력은 .js 파일 확장자를 갖습니다.
    react-native 모드는 모든 JSX를 유지하고 있다는 점에서 preserve와 같지만 대신 출력은 .js 파일 확장자를 갖습니다.
    
+
    TypeScript는 preserve, react 및 react-native라는 세 가지의 JSX 모드와 함께 제공됩니다.
+이 모드들은 방출 단계에서만 영향을 미치며, 타입 검사에는 영향을 받지 않습니다.
+preserve 모드는 다른 변환 단계(예: Babel)에 사용하도록 결과물의 일부를 유지합니다.
+또한 결과물은 .jsx 파일 확장자를 갖습니다.
+react 모드는 React.createElement를 생성하여, 사용하기 전에 JSX 변환이 필요하지 않으며, 결과물은 .js 확장자를 갖게 됩니다.
+react-native 모드는 JSX를 유지한다는 점은 preserve 모드와 동일하지만, 결과물은 .js 확장자를 갖게 된다는 점이 다릅니다.
    
 
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
-
-
-
-
+
+
+
+
    
 
 
    모드입력출력출력 파일 확장자모드입력결과결과 파일 확장자
 
    
     
 
 
    preserve<div /><div />.jsxpreserve<div /><div />.jsx
 
    
 
    react<div />React.createElement("div").jsreact<div />React.createElement("div").js
 
    
 
    react-native<div /><div />.jsreact-native<div /><div />.js
 
    
     
 
    
-
    이 모드는 커맨드 라인의 --jsx 명령 또는 tsconfig.json 파일의 해당 옵션을 사용하여 지정할 수 있습니다.
    
+
    --jsx 명령줄 플래그 또는 tsconfig.json 파일의 해당 옵션을 사용하여 모드를 지정할 수 있습니다.
    
 
    
-
    주의사항: React 식별자는 하드 코딩되어 있으므로 대문자 R.로 React를 사용할 수 있도록 해야 합니다.
    
+
    *참고: React JSX를 생성할 때 --jsxFactory 옵션으로  사용할 JSX 팩토리(JSX factory) 함수를 지정할 수 있습니다 (기본값은 React.createElement)
    
 
    
-
    as 연산자 (The as operator)
    
-
    타입 단언 작성 방법을 회상해봅시다.
    
+
    as 연산자 (The as operator)
    
+
    ↥ 위로
    
+
    타입 단언(type assertion)을 어떻게 작성하는지 떠올려 볼까요:
    
 
    var foo = <foo>bar;
 
    
-
    여기서 변수 bar의 타입을 foo라고 주장하고 있습니다.
    TypeScript도 타입 단언을 위해 꺾쇠 괄호를 사용하기 때문에 JSX의 특정 구문 파싱에는 몇가지 어려움이 있습니다.
    결과적으로 TypeScript는 .tsx 파일에 꺾쇠 괄호 타입 단언을 허용하지 않습니다.
    
-
    이러한 .tsx 파일의 기능 손실을 채우기 위해 새로운 타입의 단언 연산자가  추가되었습니다: as.
    위 예제는 쉽게 as 연산자로 다시 작성할 수 있습니다.
    
+
    위 코드는 변수 bar가 foo 타입이라는 것을 단언합니다.
+TypeScript는 꺾쇠 괄호를 사용해 타입을 단언하기 때문에, JSX 구문과 함께 사용할 경우 특정 문법 해석에 문제가 될 수도 있습니다. 결과적으로 TypeScript는 .tsx 파일에서 화살 괄호를 통한 타입 단언을 허용하지 않습니다.
    
+
    위의 구문은 .tsx 파일에서 사용할 수 없으므로, as라는 대체 연산자를 통해 타입 단언을 해야 합니다.
+위의 예시는 as 연산자로 쉽게 다시 작성할 수 있습니다.
    
 
    var foo = bar as foo;
 
    
-
    as 연산자는 .ts와 .tsx 파일 모두에서 사용할 수 있으며 다른 타입 단언 스타일과 똑같이 동작합니다.
    
+
    as 연산자는 .ts와 .tsx 파일 모두 사용할 수 있으며, 꺾쇠 괄호 형식의 단언과 동일하게 동작합니다.
    
 
    타입 검사 (Type Checking)
    
-
    JSX 타입 검사를 이해하기 위해서는 먼저 내장 요소와 값-기반 요소 사이의 차이를 이해해야 합니다.
    JSX 표현식 <expr />이 주어지면 expr은 원래 환경에 내장된 것을 참조할 수 있습니다 (예: DOM 환경의 div 또는 span) 또는 직접 작성한 사용자 정의 구성 요소를 참조할 수 있습니다.
    
-
    이것이 중요한 두 가지 이유가 있습니다:
    
+
    ↥ 위로
    
+
    JSX의 타입 검사를 이해하기 위해선, 먼저 내장 요소와 값-기반 요소의 차이점에 대해 알아야 합니다.
+JSX 표현식 <expr />에서 expr은 환경에 내장된 요소(예: DOM 환경의 div 또는 span) 혹은 사용자가 만든 사용자 정의 컴포넌트를 참조할 것입니다.
+이는 다음과 같은 두 가지 이유로 중요합니다:
    
 
      
-
    1. React의 경우, 내장 요소는 문자열 (React.createElement("div"))로 방출되는 반면 생성한 컴포넌트는 (React.createElement(MyComponent))가 아닙니다.
      2. 
-
    2. JSX 요소에서 전달되는 속성의 타입은 다르게 보여야합니다.
      내장 요소 속성은 본질적으로 알려져야 하는 반면에 컴포넌트는 자체 속성 집합을 지정하기를 원할 수 있습니다.
      3. 
+
    3. 리액트에서 내장 요소는 React.createElement("div")과 같은 문자열로 생성되는 반면, 사용자가 만든 컴포넌트는 React.createElement("MyComponent")가 아닙니다.
      4. 
+
    4. JSX 요소에 전달되는 속성의 타입은 다르게 조회되어야 합니다.
+내장 요소의 속성은 내재적으로 알고 있어야 하지만, 컴포넌트는 각각 자신의 속성 집합을 지정하려고 합니다.
      5. 
 
    
-
    TypeScript는 이러한 것들을 구분하기 위해 React와 같은 컨벤션을 사용합니다.
    내장 요소는 항상 소문자로 시작하고 값-기반 요소는 항상 대문자로 시작합니다.
    
+
    TypeScript는 React와 동일한 규칙을 사용하여 구별합니다.
+내장 요소는 항상 소문자로 시작하고 값-기반 요소는 항상 대문자로 시작합니다.
    
 
    내장 요소 (Intrinsic elements)
    
-
    내장 요소는 JSX.IntrinsicElements라는 특수한 인터페이스에서 볼 수 있습니다.
-기본적으로 이 인터페이스가 지정되지 않으면 모든 내장 요소에 타입 검사는 하지 않습니다.
    다만 이 인터페이스가 존재하는 경우, 내부 요소의 이름은 JSX.IntrinsicElements 인터페이스의 프로퍼티로서 참조됩니다.
    
-
    예를 들어:
    
+
    ↥ 위로
    
+
    내장 요소는 특수 인터페이스 JSX.IntrinsicElements에서 조회됩니다.
+기본적으로 이 인터페이스가 지정되지 않으면 그대로 진행되어 내장 요소 타입은 검사되지 않습니다.
+그러나 이 인터페이스가 있는 경우, 내장 요소의 이름은 JSX.IntrinsicElements 인터페이스의 프로퍼티로 조회됩니다.
+예를 들어:
    
 
    declare namespace JSX {
     interface IntrinsicElements {
         foo: any
     }
 }
 
-<foo />; // 좋아요
+<foo />; // 성공
 <bar />; // 오류
 
    
-
    위의 예제에서 <foo />는 잘 동작하지만 <bar />는JSX.IntrinsicElements에 지정되지 않았기 때문에 오류가 발생합니다.
    
+
    위의 예제에서 <foo />는 잘 동작하지만, <bar />는 JSX.IntrinsicElements에 지정되지 않았기 때문에 오류를 일으킵니다.
    
 
    
-
    참고: JSX.IntrinsicElements에서 다음과 같이 catch-all 문자열 indexer를 지정할 수도 있습니다:
    
+
    참고: 다음과 같이 JSX.IntrinsicElements에 catch-all 문자열 인덱서를 지정할 수도 있습니다.
    
+
    
 
    declare namespace JSX {
-   interface IntrinsicElements {
-       [elemName: string]: any;
-   }
+    interface IntrinsicElements {
+        [elemName: string]: any;
+    }
 }
 
    
-
 
    값-기반 요소 (Value-based elements)
    
-
    값 기반 요소는 스코프에 있는 식별자로 간단히 조회됩니다.
    
+
    ↥ 위로
    
+
    값-기반 요소는 해당 스코프에 있는 식별자로 간단하게 조회됩니다.
    
 
    import MyComponent from "./myComponent";
 
-<MyComponent />; // 좋아요
+<MyComponent />; // 성공
 <SomeOtherComponent />; // 오류
 
    
-
    값 기반 요소를 정의하는 방법에는 두 가지가 있습니다:
    
+
    값-기반 요소를 정의하는데엔 다음의 두 가지 방법이 있습니다:
    
 
      
-
    1. 무상태 함수형 컴포넌트 (SFC)
      2. 
-
    2. 클래스 컴포넌트
      3. 
+
    3. 함수형 컴포넌트 (FC)
      4. 
+
    4. 클래스형 컴포넌트
      5. 
 
    
-
    이 두 가지 타입의 값 기반 요소는 JSX 표현식에서 구분할 수 없기 때문에 일단 오버로드 해석을 사용하여 무상태 함수형 컴포넌트로 표현식을 해결하려고 합니다.
    프로세스가 성공하면 선언에 대한 표현식을 해결합니다.
    만약 SFC로 해결하지 못한다면 클래스 컴포넌트로 해결합니다.
    만약 실패한다면 오류를 보고합니다.
    
-
    무상태 함수형 컴포넌트(Stateless Functional Component)
    
-
    이름에서 알 수 있듯이 컴포넌트는 첫 번째 인수가 props 객체인 JavaScript 함수로 정의됩니다.
    반환 타입은 JSX.Element에 할당할 수 있도록 강제합니다.
    
+
    이 두 가지 유형의 값-기반 요소는 JSX 표현식에서 서로 구별할 수 없으므로, TS는 과부하 해결을 사용하여 먼저 함수형 컴포넌트 표현식으로 해석합니다. 이 과정이 성공적으로 진행되면, TS는 이 선언을 표현식으로 해석합니다. 함수형 컴포넌트로 해석되지 않는다면, TS는 클래스형 컴포넌트로 해석을 시도합니다. 이 과정도 실패할 경우, TS는 오류를 보고합니다.
    
+
    함수형 컴포넌트 (Function Component)
    
+
    ↥ 위로
    
+
    이름에서 알 수 있듯, 컴포넌트는 첫 번째 인수가 props 객체인 JavaScript 함수로 정의됩니다.
+TS는 컴포넌트의 반환 타입이 JSX.Element에 할당 가능하도록 요구합니다.
    
 
    interface FooProp {
   name: string;
   X: number;
@@ -817,12 +902,12 @@ 
    declare function AnotherComponent(prop: {name: string});
 function ComponentFoo(prop: FooProp) {
-  return <AnotherComponent name=prop.name />;
+  return <AnotherComponent name={prop.name} />;
 }
 
 const Button = (prop: {value: string}, context: { color: string }) => <button>
 
    
-
    SFC는 단순히 JavaScript 함수이기 때문에 여기서도 함수 오버로드를 활용할 수 있습니다.
    
+
    함수형 컴포넌트는 JavaScript 함수이므로, 함수 오버로드 또한 사용 가능합니다:
    
 
    interface ClickableProps {
   children: JSX.Element[] | JSX.Element
 }
@@ -840,15 +925,23 @@ 
    ...
 }
 
    
-
    클래스 컴포넌트 (Class Component)
    
-
    클래스 컴포넌트의 타입을 제한할 수 있습니다.
    하지만 이를 위해 새로운 두 가지를 도입해야 합니다: 요소 클래스 타입과 요소 인스턴스 타입
    
-
    <Expr />에 주어진 요소 클래스 타입은 Expr입니다.
    따라서 위 예제의 MyComponent가 ES6 클래스라면 이 클래스가 그 클래스 타입이 될 것입니다.
    만일 MyComponent가 팩토리 함수라면 클래스 타입이 그 함수가 될 것입니다.
    
-
    한 번 클래스 타입이 설정되면 인스턴스 타입은 클래스 타입의 호출 시그니처과 구조 시그니처의 반환 타입 유니온에 따라 결정됩니다.
    다시 ES6 클래스의 경우, 인스턴스 타입은 해당 클래스의 인스턴스 타입이 되고 팩토리 함수의 경우 해당 함수에서 반환되는 값의 타입이 됩니다.
    
+
    
+
    참고: 함수형 컴포넌트는 이전에 무상태 함수형 컴포넌트(SFC)로 알려져 있습니다. 하지만 최근 버전의 리액트에선 더 이상 함수형 컴포넌트를 무상태로 취급하지 않으며, SFC 타입과 그 별칭인 StatelessComponent은 더 이상 사용되지 않습니다.
    
+
    
+
    클래스형 컴포넌트 (Class Component)
    
+
    ↥ 위로
    
+
    클래스형 컴포넌트의 타입을 정의하는 것은 가능합니다.
+이를 위해선 요소 클래스 타입 과 요소 인스턴스 타입 이라는 새로운 용어를 이해해야 합니다.
    
+
    <Expr />에서, 요소 클래스 타입 은 Expr의 타입입니다.
+위의 예시에서 MyComponent가 ES6 클래스라면 이 클래스 타입은 클래스 생성자이고 전역입니다.
+MyComponent가 팩토리 함수라면, 클래스 타입은 해당 함수입니다.
    
+
    클래스 타입이 결정되면, 인스턴스 타입은 클래스 타입의 생성자 혹은 호출 시그니처(있는 것 중 어느 쪽으로든)에 의한 반환 타입을 결합하여 결정됩니다.
+따라서 ES6 클래스의 경우, 인스턴스 타입은 해당 클래스의 인스턴스 타입이 되고, 팩토리 함수의 경우엔 해당 함수로부터 반환된 값의 타입이 됩니다.
    
 
    class MyComponent {
   render() {}
 }
 
-// 구조 시그니처 사용
+// 생성자 시그니처 사용
 var myComponent = new MyComponent();
 
 // 요소 클래스 타입 => MyComponent
@@ -864,10 +957,11 @@ 
    // 호출 시그니처 사용
 var myComponent = MyFactoryFunction();
 
-// 요소 클래스 타입 => 팩토리 함수
+// 요소 클래스 타입 => MyFactoryFunction
 // 요소 인스턴스 타입 => { render: () => void }
 
    
-
    요소 인스턴스 타입이 흥미로운 이유는 JSX.ElementClass에 할당되어야 하며 그렇지 않을 경우 오류가 발생하기 때문입니다.
    기본적으로 JSX.ElementClass는 {}이지만 JSX의 사용을 적절한 인터페이스에 맞는 타입으로 제한하도록 확장할 수 있습니다.
    
+
    흥미롭게도 요소 인스턴스 타입은 JSX.ElementClass에 할당 가능해야 하며, 그렇지 않을 경우 오류를 일으킵니다.
+기본적으로 JSX.ElementClass는 {}이지만, 적절한 인터페이스에 적합한 타입으로만 JSX를 사용하도록 제한할 수 있습니다.
    
 
    declare namespace JSX {
   interface ElementClass {
     render: any;
@@ -881,8 +975,8 @@ 
    return { render: () => {} }
 }
 
-<MyComponent />; // 좋아요
-<MyFactoryFunction />; // 좋아요
+<MyComponent />; // 성공
+<MyFactoryFunction />; // 성공
 
 class NotAValidComponent {}
 function NotAValidFactoryFunction() {
@@ -893,67 +987,78 @@ 
    <NotAValidFactoryFunction />; // 오류
 
    
 
    속성 타입 검사 (Attribute type checking)
    
-
    속성 타입 검사를 하는 첫 번째 단계는 요소 속성 타입을 결정하는 것입니다.
    이것은 내장 요소와 값 기반 요소 간에 약간의 차이가 있습니다.
    
-
    내장 요소의 경우 JSX.IntrinsicElements 프로퍼티의 타입입니다.
    
+
    ↥ 위로
    
+
    속성 타입 검사를 위해선 첫 번째로 요소 속성 타입 을 결정해야 합니다.
+이는 내장 요소와 값-기반 요소 간에 약간 다른 점이 있습니다.
    
+
    내장 요소의 경우, 요소 속성 타입은 JSX.IntrinsicElements의 프로퍼티 타입과 동일합니다.
    
 
    declare namespace JSX {
   interface IntrinsicElements {
     foo: { bar?: boolean }
   }
 }
 
-// 'foo'에 대한 요소 속성 타입은 '{bar?: boolean}'입니다.
+// 'foo'의 요소 속성 타입은 '{bar?: boolean}'
 <foo bar />;
 
    
-
    값 기반 요소의 경우 조금 더 복잡합니다.
    이전에 결정된 요소 인스턴스 타입의 프로퍼티 타입에 따라 결정됩니다.
    사용할 프로퍼티는 JSX.ElementAttributesProperty에 의해 결정됩니다.
    단일 프로퍼티로 선언해야 합니다.
    그런 다음 해당 프로퍼티의 이름이 사용됩니다.
    
+
    값-기반 요소의 경우엔 조금 더 복잡합니다.
+이전에 요소 인스턴스 타입 의 프로퍼티 타입에 따라 결정됩니다.
+사용할 프로퍼티는 JSX.ElementAttributesProperty에 따라 결정됩니다.
+이는 단일 프로퍼티로 선언되어야 합니다.
+이후 해당 프로퍼티 이름을 사용합니다.
+TypeScript 2.8 부터 JSX.ElementAttributesProperty가 제공되지 않으면, 클래스 요소의 생성자 또는 함수형 컴포넌트의 첫 번째 매개변수 타입을 대신 사용할 수 있습니다.
    
 
    declare namespace JSX {
   interface ElementAttributesProperty {
-    props; // 사용할 프로퍼티 이름을 지정합니다
+    props; // 사용할 프로퍼티 이름을 지정
   }
 }
 
 class MyComponent {
-  // 요소 인스턴스 타입에 대한 프로퍼티를 지정합니다
+  // 요소 인스턴스 타입의 프로퍼티를 지정
   props: {
     foo?: string;
   }
 }
 
-// 'MyComponent'의 요소 속성 타입은 '{foo?: string}'입니다
+// 'MyComponent'의 요소 속성 타입은 '{foo?: string}'
 <MyComponent foo="bar" />
 
    
-
    요소 속성 타입은 JSX에서 속성을 타입을 확인하는 데 사용됩니다.
    선택적 프로퍼티와 필수 프로퍼티가 지원됩니다.
    
+
    요소 속성 타입은 JSX에서 속성 타입을 확인하는데 사용됩니다.
+선택적 혹은 필수적인 프로퍼티들이 지원됩니다.
    
 
    declare namespace JSX {
   interface IntrinsicElements {
     foo: { requiredProp: string; optionalProp?: number }
   }
 }
 
-<foo requiredProp="bar" />; // 좋아요
-<foo requiredProp="bar" optionalProp={0} />; // 좋아요
-<foo />; // 오류, requiredProp이 없습니다
-<foo requiredProp={0} />; // 오류, requiredProp이 문자열이어야 합니다.
-<foo requiredProp="bar" unknownProp />; // 오류, unknownProp이 존재하지 않습니다.
-<foo requiredProp="bar" some-unknown-prop />; // 좋아요, 'some-unknown-prop' 은 유효한 식별자가 아니기 때문입니다.
+<foo requiredProp="bar" />; // 성공
+<foo requiredProp="bar" optionalProp={0} />; // 성공
+<foo />; // 오류, requiredProp이 누락됨
+<foo requiredProp={0} />; // 오류, requiredProp은 문자열이어야 함
+<foo requiredProp="bar" unknownProp />; // 오류, unknownProp은 존재하지 않음
+<foo requiredProp="bar" some-unknown-prop />; // 성공, 'some-unknown-prop'은 유효한 식별자가 아니기 때문에
 
    
 
    
-
    참고: 속성 이름이 유효한 JS 식별자 (예 :data- *속성)가 아닌 경우 요소 속성 타입에서 속성 이름을 찾을 수 없으면 오류로 간주되지 않습니다.
    
+
    참고: 만약 속성 이름이 유효한 JavaScript 식별자(data-* 속성 등)가 아닌 경우, 해당 이름을 요소 속성 타입에서 찾을 수 없어도 오류로 간주하지 않습니다.
    
 
    
-
    전개 연산자도 작동합니다:
    
+
    추가적으로, JSX.IntrinsicAttributes 인터페이스는 일반적으로 컴포넌트의 props나 인수로 사용되지 않는 JSX 프레임워크를 위한 추가적인 프로퍼티를 지정할 수 있습니다. - 예를 들면 React의 key. 더 나아가서, JSX.IntrinsicClassAttributes<T> 제네릭 타입을 사용하여 클래스형 컴포넌트에 대해 동일한 종류의 추가 속성을 지정할 수 있습니다 (함수형 컴포넌트 제외하고). 이 유형에서, 제네릭의 매개변수는 클래스 인스턴스 타입에 해당합니다. React의 경우, 이는 Ref<T> 타입의 ref 속성을 허용하는 데에 쓰입니다. 일반적으로는, JSX 프레임워크 사용자가 모든 태그에 특정 속성을 제공할 필요가 없다면, 이런 인터페이스의 모든 프로퍼티는 선택적이어야 합니다.
    
+
    스프레드 연산자 또한 동작합니다:
    
 
    var props = { requiredProp: "bar" };
-<foo {...props} />; // 좋아요
+<foo {...props} />; // 성공
 
 var badProps = {};
 <foo {...badProps} />; // 오류
 
    
-
    하위 타입 검사 (Children Type Checking)
    
-
    2.3 버전에서 하위 타입 검사를 도입했습니다.
    하위(children)는 요소 타입 검사에서 결정된 요소 속성 타입의 프로퍼티 입니다.
    JSX.ElementAttributesProperty를 사용하여 props 이름을 결정하는 것과 마찬가지로 JSX.ElementChildrenAttribute를 사용하여 하위 이름을 결정합니다.
    JSX.ElementChildrenAttribute는 단일 프로퍼티로 선언해야합니다.
    
+
    자식 타입 검사 (Children Type Checking)
    
+
    ↥ 위로
    
+
    TypeScript 2.3부터, TS는 자식 의 타입 검사를 도입했습니다. 자식 은 자식 JSX 표현식 을 속성에 삽입하는 요소 속성 타입의 특수한 프로퍼티입니다.
+TS는 JSX.ElementAttributesProperty를 사용해 props 를 결정하는 것과 유사하게, JSX.ElementChildrenAttribute를 사용해 해당 props 내의 자식 의 이름을 결정합니다.
+JSX.ElementChildrenAttribute는 단일 프로퍼티로 선언되어야 합니다.
    
 
    declare namespace JSX {
   interface ElementChildrenAttribute {
-    children: {};  // 사용할 하위 이름을 지정하세요
+    children: {};  // 사용할 자식의 이름을 지정
   }
 }
 
    
-
    하위의 타입을 명시적으로 지정하지 않는다면 React typings의 기본 타입을 사용합니다.
    
 
    <div>
   <h1>Hello</h1>
 </div>;
@@ -963,13 +1068,13 @@ 
    World
 </div>;
 
-const CustomComp = (props) => <div>props.children</div>
+const CustomComp = (props) => <div>{props.children}</div>
 <CustomComp>
   <div>Hello World</div>
   {"This is just a JS expression..." + 1000}
 </CustomComp>
 
    
-
    다른 속성과 마찬가지로 하위 타입을 지정할 수 있습니다.
    이렇게 하면 React typings에서 기본 타입을 덮어쓰게 됩니다.
    
+
    다른 속성처럼 자식 의 타입도 지정할 수 있습니다. 예를 들어 React 타이핑 을 사용하는 경우 기본 타입을 오버라이드 할 것입니다.
    
 
    interface PropsType {
   children: JSX.Element
   name: string
@@ -979,45 +1084,52 @@ 
    render() {
     return (
       <h2>
-        this.props.children
+        {this.props.children}
       </h2>
     )
   }
 }
 
-// 좋아요
-<Component>
+// 성공
+<Component name="foo">
   <h1>Hello World</h1>
 </Component>
 
-// 오류: 하위 타입은 JSX.Element의 배열이 아닌 JSX.Element 타입입니다.
-<Component>
+// 오류 : 자식은 JSX.Element의 배열이 아닌 JSX.Element 타입입니다.
+<Component name="bar">
   <h1>Hello World</h1>
   <h2>Hello World</h2>
 </Component>
 
-// 오류: 하위 타입은 JSX.Element 또는 string의 배열이 아닌 JSX.Element 타입입니다.
-<Component>
+// 오류 : 자식은 JSX.Element의 배열이나 문자열이 아닌 JSX.Element 타입입니다.
+<Component name="baz">
   <h1>Hello</h1>
   World
 </Component>
 
    
 
    JSX 결과 타입 (The JSX result type)
    
-
    기본적으로 JSX 표현식의 결과 타입은 any로 분류됩니다.
    JSX.Element 인터페이스를 지정하여 사용자 정의 타입을 사용할 수 있습니다.
    그러나 이 인터페이스에서 JSX의 요소, 속성 또는 하위 항목에 대한 타입 정보를 찾을 수 없습니다.
    이것은 블랙박스 입니다.
    
+
    ↥ 위로
    
+
    기본적으로 JSX 표현식의 결과물은 any 타입입니다.
+JSX.Element 인터페이스를 수정하여 특정한 타입을 지정할 수 있습니다.
+그러나 이 인터페이스에서는 JSX의 요소, 속성, 자식에 대한 정보를 검색할 수 없습니다.
+이 인터페이스는 블랙박스입니다.
    
 
    표현식 포함하기 (Embedding Expressions)
    
-
    JSX는 중괄호 ({ })로 표현식을 감싸고 태그 사이에 표현식을 삽입할 수 있게합니다.
    
+
    ↥ 위로
    
+
    JSX는 중괄호({ })로 표현식을 감싸 태그 사이에 표현식 사용을 허용합니다.
    
 
    var a = <div>
   {["foo", "bar"].map(i => <span>{i / 2}</span>)}
 </div>
 
    
-
    위의 코드는 문자열을 숫자로 나눌 수 없으므로 오류가 발생합니다.
    
-
    출력은 preserve 옵션을 사용할 때 다음과 같습니다:
    
+
    위의 코드는 문자열을 숫자로 나눌 수 없으므로 오류를 일으킵니다.
+preserve 옵션을 사용할 때, 결과는 다음과 같습니다:
    
 
    var a = <div>
   {["foo", "bar"].map(function (i) { return <span>{i / 2}</span>; })}
 </div>
 
    
-
    리액트 통합 (React integration)
    
-
    React와 함께 JSX를 사용하려면 React typings을 사용해야 합니다.
    이러한 typings은 React와 함께 사용하기에 적합하도록 JSX 네임스페이스를 적절하게 정의합니다.
    
+
    리액트와 통합하기 (React integration)
    
+
    ↥ 위로
    
+
    리액트에서 JSX를 사용하기 위해선 React 타이핑을 사용해야 합니다.
+이는 리액트를 사용할 수 있도록 JSX 네임스페이스를 적절하게 정의합니다.
    
 
    /// <reference path="react.d.ts" />
 
 interface Props {
@@ -1030,9 +1142,22 @@ 
    리&#x
   }
 }
 
-<MyComponent foo="bar" />; // 좋아요
+<MyComponent foo="bar" />; // 성공
 <MyComponent foo={0} />; // 오류
 
    
+
    팩토리 함수 (Factory Functions)
    
+
    ↥ 위로
    
+
    jsx: react 컴파일러 옵션에서 사용하는 팩토리 함수는 설정이 가능합니다. 이는 jsxFactory 명령 줄 옵션을 사용하거나 인라인 @jsx 주석을 사용하여 파일별로 설정할 수 있습니다. 예를 들어 jsxFactory에 createElement를 설정했다면, <div />는 React.createElement("div") 대신 createElement("div")으로 생성될 것입니다.
    
+
    주석 pragma 버전은 다음과 같이 사용할 수 있습니다 (TypeScript 2.8 기준):
    
+
    import preact = require("preact");
+/* @jsx preact.h */
+const x = <div />;
+
    
+
    이는 다음처럼 생성됩니다:
    
+
    const preact = require("preact");
+const x = preact.h("div", null);
+
    
+
    선택된 팩토리는 전역 네임스페이스로 돌아가기 전에 JSX 네임스페이스(타입 검사를 위한 정보)에도 영향을 미칩니다. 팩토리가 React.createElement(기본값)로 정의되어 있다면, 컴파일러는 전역 JSX를 검사하기 전에 React.JSX를 먼저 검사할 것입니다. 팩토리가 h로 정의되어 있다면, 컴파일러는 전역 JSX를 검사하기 전에 h.JSX를 검사할 것입니다.
    
 
                                 
                                 
    
@@ -1076,7 +1201,7 @@ 
    No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"JSX","level":"3.18","depth":1,"next":{"title":"데코레이터","level":"3.19","depth":1,"path":"pages/Decorators.md","ref":"pages/Decorators.md","articles":[]},"previous":{"title":"선언 병합","level":"3.17","depth":1,"path":"pages/Declaration Merging.md","ref":"pages/Declaration Merging.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/JSX.md","mtime":"2019-06-14T05:32:52.243Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"JSX","level":"3.18","depth":1,"next":{"title":"데코레이터","level":"3.19","depth":1,"path":"pages/Decorators.md","ref":"pages/Decorators.md","articles":[]},"previous":{"title":"선언 병합","level":"3.17","depth":1,"path":"pages/Declaration Merging.md","ref":"pages/Declaration Merging.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/JSX.md","mtime":"2020-04-22T15:29:36.175Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Mixins.html b/pages/Mixins.html
index 5d1a43f2..61a4ae1f 100644
--- a/pages/Mixins.html
+++ b/pages/Mixins.html
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
    • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
  • 
+        
  • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
    • 
+    
+        
  • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
  • 릴리즈 노트
    • 
+        
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
    • 
+    
+
+    
 
     
  • 
 
@@ -711,11 +757,12 @@ 
    
     
                                 
    
                                 
-                                
    소개
    
-
    전통적인 OO 계층 구조와 함께 재사용 가능한 컴포넌트로 클래스를 구축하는 또 다른 보편적인 방법은 더 간단한 부분의 클래스를 결합하여 클래스를 구축하는 것입니다.
    여러분은 스칼라와 같은 언어에서의 믹스인이나 특성에 대한 사상에 익숙할 수 있으며 이 패턴은 JavaScript 커뮤니티에서도 인기를 얻고 있습니다.
    
-
    믹스인 샘플
    
-
    아래 코드에서는 TypeScript에서 믹스인을 모델링하는 방법을 보여줍니다.
    코드가 끝나면 어떻게 작동하는지 분석해보겠습니다.
    
-
    // Disposable 믹스인
+                                
    Mixin
    
+
    소개(Introduction)
    
+
    전통적인 객쳬지향 계층과 함께, 재사용 가능한 컴포넌트로 부터 클래스를 빌드하는 또 다른 일반적인 방법으로, 간단한 부분클래스를 결합하여 빌드하는 것입니다. 스칼라 등의 언어를 통해서, 믹스인에 대한 개념과 특성은 익숙할 수 있을 것이며, 패턴은 JavaScript 커뮤니티에서도 어느 정도의 인기를 얻었습니다.
    
+
    예시 코드(Code Sample)
    
+
    아래 코드에서는 TypeScript에서 mixin의 모델링 방식을 보여줍니다. 코드를 본 후, 작동 방식을 살펴보도록 하겠습니다.
    
+
    // Disposable Mixin
 class Disposable {
     isDisposed: boolean;
     dispose() {
@@ -724,8 +771,8 @@ 
    믹스인 
 
 }
 
-// Activatable 믹스인
-class Activatable {
+// Activatable Mixin
+class Actiavatable {
     isActive: boolean;
     activate() {
         this.isActive = true;
@@ -735,7 +782,7 @@ 
    믹스인 
     }
 }
 
-class SmartObject implements Disposable, Activatable {
+class SmartObject {
     constructor() {
         setInterval(() => console.log(this.isActive + " : " + this.isDisposed), 500);
     }
@@ -743,35 +790,29 @@ 
    믹스인 
     interact() {
         this.activate();
     }
-
-    // Disposable
-    isDisposed: boolean = false;
-    dispose: () => void;
-    // Activatable
-    isActive: boolean = false;
-    activate: () => void;
-    deactivate: () => void;
 }
+
+interface SmartObject extends Disposable, Activatable {}
 applyMixins(SmartObject, [Disposable, Activatable]);
 
 let smartObj = new SmartObject();
 setTimeout(() => smartObj.interact(), 1000);
 
 ////////////////////////////////////////
-// 런타임 라이브러리 어딘가에
+// In your runtime library somewhere
 ////////////////////////////////////////
 
 function applyMixins(derivedCtor: any, baseCtors: any[]) {
     baseCtors.forEach(baseCtor => {
         Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
-            derivedCtor.prototype[name] = baseCtor.prototype[name];
+            Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name));
         });
     });
 }
 
    
-
    샘플 이해하기
    
-
    믹스인으로 작동할 코드 샘플은 두 클래스로 시작합니다.
    각각의 개체가 특정 활동이나 능력에 초점을 맞추고 있다는 것을 볼 수 있습니다.
    나중에는 이 두 가지를 결합하여 새로운 클래스를 만들겠습니다.
    
-
    // Disposable
+
    예시 알아보기(Understanding the sample)
    
+
    예시 코드는 mixin을 수행하는 두 클래스로 시작합니다. 두 클래스는 각각 부분적인 기능에 집중되어 있음을 알 수 있습니다. 이후에는 두 기능을 모두 사용하여 새로운 클래스를 만들기 위해 이들을 혼합(mix)할 것입니다.
    
+
    // Disposable Mixin
 class Disposable {
     isDisposed: boolean;
     dispose() {
@@ -780,7 +821,7 @@ 
    샘플 
 
 }
 
-// Activatable
+// Activatable Mixin
 class Activatable {
     isActive: boolean;
     activate() {
@@ -791,27 +832,23 @@ 
    샘플 
     }
 }
 
    
-
    다음으로 두 믹스인의 결합을 처리할 클래스를 만들 것입니다.
    이 기능에 대해 자세히 살펴보겠습니다:
    
-
    class SmartObject implements Disposable, Activatable {
-
    
-
    위에서 첫 번째로 주목할 점은 extends 대신 implements를 사용한다는 것입니다.
    이것은 클래스를 인터페이스로 다루고 구현이 아닌 Disposable과 Activatable 타입만 사용합니다.
    즉, 클래스에서 구현을 제공해야 합니다.
    이외에 정확하게는 믹스인 사용하여 회피하고 싶은 것입니다.
    
-
    이 요구 사항을 충족시키기 위해 믹스인에서 가져올 멤버에 대해 stand-in 프로퍼티과 그 타입을 생성합니다.
    이것은 컴파일러가 런타임에 이러한 멤버를 사용할 수 있음을 충족시킵니다.
    비록 약간의 bookkeeping 오버헤드가 있기는 하지만 여전히 믹스인의 이점을 얻을 수 있습니다.
    
-
    // Disposable
-isDisposed: boolean = false;
-dispose: () => void;
-// Activatable
-isActive: boolean = false;
-activate: () => void;
-deactivate: () => void;
+
    다음으로, 두 mixin의 결합을 처리 할 클래스를 만듭니다. 이것이 어떻게 작동하는지 더 자세히 살펴 보겠습니다.
    
+
    class SmartObject {
+    ...
+}
+
+interface SmartObject extends Disposable, Activatable {}
 
    
-
    마지막으로, 믹스인을 클래스에 믹싱하여 완벽한 구현을 만들어냅니다.
    
+
    첫 번째 사항은 SmartObject 클래스에서 Disposable과 Activatable을 확장하는 대신 SmartObject 인터페이스에서 확장한다는 것입니다. Declaration merging으로 인해 SmartObject 인터페이스가 SmartObject 클래스에 혼합됩니다.
    
+
    클래스를 인터페이스로 취급하고 Disposable 및 Activatable 뒤에있는 유형 만 구현이 아닌 SmartObject 유형으로 혼합합니다. 이것은 우리가 클래스에서 구현에서 mixin을 제공해야 한다는 것을 의미합니다. 그 외에는 mixin의 사용을 피할 수 있습니다.
    
+
    마지막으로 클래스에 구현에서, mixin을 혼합(mix)합니다.
    
 
    applyMixins(SmartObject, [Disposable, Activatable]);
 
    
-
    마지막으로 믹스인을 하기 위한 헬퍼 함수를 만듭니다.
    이것은 각 믹스인의 프로퍼티를 거쳐 실행되며 믹스인의 타겟으로 복사하고 구현된 stand-in 프로퍼티로 채우게 됩니다.
    
+
    마지막으로, 우리를 위해 mixin을 수행 할 도우미 함수를 만듭니다. 그러면 각 mixin의 속성이 실행되고 mixin의 대상으로 복사되어 독립형 속성을 구현합니다.
    
 
    function applyMixins(derivedCtor: any, baseCtors: any[]) {
     baseCtors.forEach(baseCtor => {
         Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
-            derivedCtor.prototype[name] = baseCtor.prototype[name];
+            Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name));
         });
     });
 }
@@ -859,7 +896,7 @@ 
    No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"믹스인","level":"3.20","depth":1,"next":{"title":"트리플-슬래시 지시자","level":"3.21","depth":1,"path":"pages/Triple-Slash Directives.md","ref":"pages/Triple-Slash Directives.md","articles":[]},"previous":{"title":"데코레이터","level":"3.19","depth":1,"path":"pages/Decorators.md","ref":"pages/Decorators.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Mixins.md","mtime":"2019-06-14T05:32:52.244Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"믹스인","level":"3.20","depth":1,"next":{"title":"트리플-슬래시 지시자","level":"3.21","depth":1,"path":"pages/Triple-Slash Directives.md","ref":"pages/Triple-Slash Directives.md","articles":[]},"previous":{"title":"데코레이터","level":"3.19","depth":1,"path":"pages/Decorators.md","ref":"pages/Decorators.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Mixins.md","mtime":"2020-04-22T15:29:36.175Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Module Resolution.html b/pages/Module Resolution.html
index cf084111..2323d875 100644
--- a/pages/Module Resolution.html	
+++ b/pages/Module Resolution.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
    • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
  • 
+        
  • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
    • 
+    
+        
  • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
  • 릴리즈 노트
    • 
+        
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
    • 
+    
+
+    
 
     
  • 
 
@@ -712,41 +758,57 @@ 
    
                                 
    
                                 
                                 
    
-
    이번 섹션에서는 모듈에 대한 몇 가지 기본 지식을 전제로합니다. 자세한 내용은 모듈을 참조하세요.
    
+
    이번 섹션은 모듈에 대한 기초적인 지식을 전제로 합니다.
+더 많은 정보는 모듈을 보도록 하세요.
    
 
    
-
    모듈 resolution은 import가 무엇을 참조하는지 파악하기 위해 컴파일러가 사용하는 프로세스입니다.
    import { a } from "moduleA"와 같은 import 문을 고려하세요.  
    
-
    a의 사용을 검사하기 위해서는 컴파일러는 그것이 무엇을 의미하는지 정확히 알아야 하며 그것의 정의인 moduleA를 검사해야 할 필요가 있습니다.
    
-
    이때 컴파일러가 "moduleA의 형태가 무엇입니까?"라고 묻습니다.
    이것은 간단하게 들릴지 모르지만 moduleA는 자신의 .ts/.tsx 파일들 중 하나 또는 사용자의 코드가 의존하는 .d.ts 파일 중 하나에서 정의될 수 있습니다.
    
-
    먼저 컴파일러는 가져온 모듈을 나타내는 파일을 찾습니다.
    이렇게하기 위해 컴파일러는 다음 두 가지 전략 중 하나를 따릅니다: 클래식 또는 노드.
    이 전략은 컴파일러에게 moduleA를 찾을 위치를 알려줍니다.
    
-
    그래도 작동하지 않고 모듈 이름이 관련이 없는 경우("moduleA"의 경우에는)  컴파일러는 ambient module declaration을 찾으려고 시도할 것입니다.
    다음에 Non-relative imports에 대해 다룰 것입니다.
    
-
    마지막으로 컴파일러가 모듈을 해석하지 못하면 오류를 기록합니다.
    이 경우 오류는 오류 TS2307 : 모듈 'moduleA'을 찾을 수 없습니다.
    
+
    모듈 해석 (module resolution) 은 컴파일러가 imoprt가 무엇을 참조하는지 알아내기 위해 사용하는 프로세스입니다.
+import { a } from "moduleA"같은 import 문을 생각해보세요;
+a의 모든 사용을 검사하기 위해, 컴파일러는 무엇을 참조하는지 정확히 알아야 할 필요가 있습니다, 그리고 moduleA 정의를 검사해야 할 필요가 있습니다.
    
+
    이 시점에, 컴파일러는 "moduleA의 형태가 뭘까?"라고 질문할 것입니다.
+간단해 보이지만, moduleA는 .ts/.tsx 파일에 정의되어 있거나 혹은 코드가 의존하는 .d.ts에 정의되어 있을 수 있습니다.
    
+
    첫 번째로, 컴파일러는 가져온 모듈을 나타내는 파일의 위치를 찾으려고 할 것입니다.
+그렇게 하기 위해 컴파일러는 두 가지 다른 전략 중 하나를 따릅니다: 클래식 혹은 [노드][#노드-node].
+이 전략들은 컴파일러가 moduleA를 찾기 위해 어디를 봐야 할지 알려줍니다.
    
+
    만약 이 방법이 잘 안되고 모듈 이름이 비-상대적이라면 ("moduleA의 경우가 그렇습니다), 컴파일러는 ambient 모듈 선언을 찾으려고 할 것입니다.
+비-상대적 import는 다음에 다룰 것입니다.
    
+
    마지막으로, 컴파일러가 모듈을 해석할 수 없다면, 오류 로그가 발생합니다.
+이 경우에, 오류는 error TS2307: Cannot find module 'moduleA와 같습니다.
    
 
    상대적 vs. 비-상대적 모듈 import (Relative vs. Non-relative module imports)
    
-
    모듈 imports는 모듈 참조가 상대적인지 아닌지에 따라 다르게 처리됩니다.
    
-
    relative import는 /, ./ 또는 ../ 로 시작하는 임포트입니다.
    몇 가지 예는 다음과 같습니다:
    
+
    모듈 참조가 상대적 혹은 비-상대적이냐에 따라 모듈 import는 다르게 해석됩니다.
    
+
    상대적 import 는 /, ./ 혹은 ../. 중에 하나로 시작합니다.
+일부 예제는 다음과 같습니다:
    
 
      
 
    • import Entry from "./components/Entry";
      • 
 
    • import { DefaultHeaders } from "../constants/http";
      • 
 
    • import "/mod";
      • 
 
    
-
    다른 모든 import는 non-relative로 간주됩니다.
    몇 가지 예는 다음과 같습니다:
    
+
    다른 모든 import는 비-상대적 으로 간주됩니다.
+일부 예제는 다음과 같습니다:
    
 
      
 
    • import * as $ from "jquery";
      • 
 
    • import { Component } from "@angular/core";
      • 
 
    
-
    import된 파일과 관련하여 relative import가 해석되었으며 ambient module declaration에 으로 해석할 수는 없습니다.
    상대적인 위치를 런타임에 유지할 수 있도록 보장되는 모듈에 relative imports를 사용해야 합니다.
    
-
    non-relative import는 baseUrl을 기준 또는 경로 매핑을 통해 해석될 수 있습니다.
    또한 ambient module declarations으로 해석할 수도 있습니다.
    외부의 의존성을 가져올 때는 non-relative 경로를 사용하세요.
    
+
    상대적 import는 가져온 파일에 상대적으로 해석되고 ambient 모듈 선언으로 해석 될 수 없습니다.
+자신의 모듈에 대해서는 런타임에 상대적 위치를 유지하는 것을 보장하는 상대적 import를 사용해야 합니다.
    
+
    비-상대적 import는 baseUrl로 해석되거나, 밑에서 다루게 될 경로 매핑으로 해석될 수 있습니다.
+ambient 모듈 선언으로도 해석될 수 있습니다.
+외부 의존성을 import 할 때, 비-상대적 경로를 사용하세요.
    
 
    모듈 해석 전략 (Module Resolution Strategies)
    
-
    모듈 해석 전략에는 두가지가 있습니다: 노드와 클래식.
    --moduleResolution를 사용하여 모듈 해석 전략을 지정할 수 있습니다.
    지정하지 않은 경우 기본값은 --module AMD | System | ES2015인 경우 클래식이며 그렇지 않다면 노드입니다.
    
+
    두 가지 가능한 모듈 해석 전략이 있습니다: 노드와 클래식.
+--moduleResolution 플래그를 사용하여 모듈 해석 전략을 지정할 수 있습니다.
+지정되지 않았으면, 디폴트는 --module AMD | System | ES2015에서는 [클래식][#클래식-classic]이고 나머지는 노드입니다.
    
 
    클래식 (Classic)
    
-
    이것은 TypeScript의 기본 해석 전략이었습니다.
    요즘은 주로 이전 버전과의 호환성을 위해 이 전략이 존재합니다.
    
-
    relative import는 import된 파일과 관련하여 해석됩니다.
    그러므로 소스 파일 /root/src/folder/A.ts에 있는 import { b } from "./moduleB"를 실행하면 다음과 같은 결과가 나옵니다:
    
+
    TypeScript의 디폴트 해석 전략으로 사용됩니다.
+요즘에, 이 전략은 주로 이전 버전과의 호환성을 위해 제공됩니다.
    
+
    상대적 import는 import하는 파일에 상대적으로 해석됩니다.
+그래서 소스 파일 /root/src/folder/A.ts안에 import { b } from "./moduleB"`는 다음과 같이 조회합니다:
    
 
      
 
    1. /root/src/folder/moduleB.ts
      2. 
 
    2. /root/src/folder/moduleB.d.ts
      3. 
 
    
-
    그러나 non-relative 모듈 imports의 경우 컴파일러는 imports 파일이 포함된 디렉토리부터 시작하여 일치하는 정의 파일을 가져오기 위해 디렉토리 트리를 찾으려합니다.
    
+
    그러나, 비-상대적 모듈 import에서는, 컴파일러가 가져온 파일을 갖고 있는 디렉터리부터 시작해서 디렉터리 트리를 거슬러 올라가 맞는 정의 파일의 위치를 찾으려고 합니다.
    
 
    예를 들어:
    
-
    moduleB를 소스 파일에서 import { b } from "moduleB"와 같이 상대적으로 가져오지 않으면 "moduleB"를 찾기 위해 다음과 같은 위치에서 찾게 됩니다:
    
+
    소스 파일 /root/src/folder/A.ts안에 import { b } from "moduleB"처럼 moduleB의 비-상대적 import은 "moduleB"의 위치를 찾기 위해 다음과 같은 위치를 찾습니다.
    
 
      
 
    1. /root/src/folder/moduleB.ts
      2. 
 
    2. /root/src/folder/moduleB.d.ts
      3. 
@@ -758,56 +820,70 @@ 
      클래식 (Classic)
      /moduleB.d.ts
 
    
 
    노드 (Node)
    
-
    이 해석 전략은 런타임에 Node.js 모듈 분석 메커니즘을 모방하려고 시도합니다.
    전체 Node.js 해석 알고리즘은 Node.js 모듈 문서에 설명되어 있습니다.
    
-
    Node.js 모듈 해석 방법 (How Node.js resolves modules)
    
-
    TS 컴파일러가 따르는 단계를 이해하려면 Node.js 모듈에 대해 설명하는 것이 중요합니다.
    전통적으로, Node.js의 import는 require라는 함수를 호출함으로써 수행됩니다.
    Node.js가 취하는 동작은 require에 상대 경로인지 비-상대 경로인지에 따라 달라집니다.
    
-
    상대 경로는 매우 간단합니다.
    예를 들어 var x = require("./moduleB"); import가 포함된 /root/src/moduleA.js에 있는 파일을 살펴보겠습니다.
    Node.js는 가져 오기를 다음 순서로 해석합니다:
    
+
    이 해석 전략은 런타임에 Node.js의 모듈 해석 메커니즘을 모방하려고 시도합니다.
+전체 Node.js 해석 알고리즘은 Node.js 모듈 문서에 요약되어 있습니다.
    
+
    Node.js가 모듈을 해석하는 방법 (How Node.js resolves modules)
    
+
    TS 컴파일러가 어떤 과정을 따를지 이해하기 위해서는, Node.js 모듈을 이해하는 것이 중요합니다.
+전통적으로, Node.js의 import는 require 함수를 호출해 수행합니다.
+Node.js의 동작은 require에 상대적 경로 혹은 비-상대적 경로가 주어지는지에 따라 달라집니다.
    
+
    상대적 경로는 아주 간단합니다.
+예를 들어, var x = require("./moduleB");라는 import 문을 포함한 /root/src/moduleA.js에 위치한 파일을 생각해봅시다.
+Node.js는 다음 순서로 import를 해석합니다:
    
 
      
-
    1. /root/src/moduleB.js라는 이름의 파일이 존재합니다.
      
+
    2. /root/src/moduleB.js라는 파일이 존재하는지 확인.
      
 
      3. 
-
    3. "main" 모듈을 지정하는 package.json 파일이 포함된 경우 /root/src/moduleB 폴더로 지정합니다.
      이 예에서, Node.js가 { "main": "lib/mainModule.js" }를 포함하는 /root/src/moduleB/package.json 파일을 찾으면 Node.js는 /root/src/moduleB/lib/mainModule.js를 참조합니다.
      
+
    4. 만약 "main" 모듈을 지정하는 package.json라는 파일을 포함하고 있으면, /root/src/moduleB 폴더 확인하기.
+이 예제에서는, 만약 Node.js가 { "main": "lib/mainModule.js" }을 포함하는 /root/src/moduleB/package.json파일을 찾았다면, Node.js가 /root/src/moduleB/lib/mainModule.js를 참조할 것입니다.
      
 
      5. 
-
    5. index.js라는 파일이 포함되어 있다면 /root/src/moduleB 폴더로 간주합니다.
      그 파일은 암시적으로 그 폴더의 "메인" 모듈로 여겨집니다.
      
+
    6. index.js 라는 파일을 포함하고 있으면, /root/src/moduleB 확인하기.
+ 이 파일은 폴더의 "main" 모듈임을 암시적으로 나타냅니다.
      
 
      7. 
 
    
-
    이에 대한 자세한 내용은 파일 모듈과 폴더 모듈에 대한 Node.js 문서를 참조하세요.
    
-
    그러나 non-relative module name의 해석은 다르게 수행됩니다.
    node는 node_modules라는 특수 폴더에서 모듈을 검색합니다.
    node_modules 폴더는 현재 파일과 동일한 레벨이거나 디렉토리 체인에서 상위 레벨 일 수 있습니다.
    node는 불러오기 위한 모듈을 찾을 때까지 각 node_modules를 보고 디렉토리 체인을 거슬러 올라갑니다.
    
-
    위의 예제를 따르면, /root/src/moduleA.js가 비-상대 경로를 대신 사용하여 var x = require("moduleB"); import를 가지고 있는지 고려해보세요.
    
-
    그런 다음 Node는 moduleB가 작동할 때까지 각 위치에 대해 해석을 시도합니다.
    
+
    자세한 내용은 Node.js 문서 파일 모듈과 폴더 모듈에서 더 읽어보실 수 있습니다.
    
+
    그러나, 비-상대적 모듈 이름에 대한 해석은 다르게 수행합니다.
+Node는 node_modules로 불리는 특별한 폴더에서 모듈을 찾을 것입니다.
+node_modules 폴더는 현재 파일과 동일한 레벨이거나, 디렉터리 체인에서 더 높을 수도 있습니다.
+Node는 디렉터리 체인을 올라가, 로드하려는 모듈을 찾을 때까지 각 node_modules을 찾습니다.
    
+
    위의 예제를 따라서, /root/src/moduleA.js가 대신 비-상대적 경로를 사용하고 var x = require("moduleB"); import를 가지고 있다고 생각해봅시다.
+Node는 하나가 일치할 때까지 각 위치에서 moduleB를 해석하려고 시도합니다.
    
 
      
 
    1. /root/src/node_modules/moduleB.js
      2. 
-
    2. /root/src/node_modules/moduleB/package.json ("main" 프로퍼티 지정)
      3. 
+
    3. /root/src/node_modules/moduleB/package.json ("main" 항목을 지정했다면)
      4. 
 
    4. /root/src/node_modules/moduleB/index.js
 

      5. 
 
    5. /root/node_modules/moduleB.js
      6. 
-
    6. /root/node_modules/moduleB/package.json ("main" 프로퍼티 지정)
      7. 
+
    7. /root/node_modules/moduleB/package.json ("main" 항목을 지정했다면)
      8. 
 
    8. /root/node_modules/moduleB/index.js
 

      9. 
 
    9. /node_modules/moduleB.js
      10. 
-
    10. /node_modules/moduleB/package.json ("main" 프로퍼티 지정)
      11. 
+
    11. /node_modules/moduleB/package.json ("main" 항목을 지정했다면)
      12. 
 
    12. /node_modules/moduleB/index.js
      13. 
 
    
-
    Node.js가 (4)와 (7)에서 디렉토리 이동했음을 주목하세요.
    
-
    이 프로세스에 대한 자세한 내용은 node_modules에서 모듈을 로드하는 방법에 대한 node.js 문서를 참조하세요.
    
-
    TypeScript 모듈 해석 방법 (How TypeScript resolves modules)
    
-
    TypeScript는 컴파일 타임에 모듈에 대한 정의 파일을 찾기 위해 Node.js 런타임 해석 전략을 모방합니다.
    이를 달성하기 위해 TypeScript는 TypeScript 원본 파일 확장자 (.ts, .tsx, 및 .d.ts)을 노드의 해석 로직 위에 덮어씌웁니다.
    TypeScript는 또한 "main"의 목적을 반영하기 위해 package.json에 있는 `types" 필드를 사용합니다 - 컴파일러가 이를 사용하여 참조할 "main" 정의 파일을 찾습니다.
    
-
    예를 들어 /root/src/moduleA.ts에서 import { b } from "./moduleB"와 같은 import 문은 "./moduleB"를 찾기 위해 다음 위치에서 시도하게됩니다:
    
+
    Node.js가 (4) 와 (7)에서 디렉터리를 점프했다는 것에 주목하세요.
    
+
    프로세스에 대한 더 많은 정보는 Node.js 문서 node_modules에서 모듈 로드하기에서 읽어보실 수 있습니다.
    
+
    TypeScript가 모듈을 해석하는 방법 (How TypeScript resolves modules)
    
+
    TypeScript는 컴파일-타임에 모듈의 정의 파일 위치를 찾기 위해 Node.js의 런타임 해석 전략을 모방합니다.
+이를 달성하기 위해, TypeScript는 TypeScript 소스 파일 확장자 (.ts, .tsx 와 .d.ts)를 Node의 해석 로직 위에 씌웁니다.
+TypeScript는 "main"의 목적 - 컴파일러가 이를 사용하여 참조할 "main" 정의 파일을 찾음. 을 반영하기 위해 "types"라는 package.json안에 필드를 사용합니다
    
+
    예를 들어, /root/src/moduleA.ts안에 import { b } from "./moduleB" 같은 import 문은 "./moduleB"의 위치를 찾기 위해 다음과 같은 위치를 찾습니다.
    
 
      
 
    1. /root/src/moduleB.ts
      2. 
 
    2. /root/src/moduleB.tsx
      3. 
 
    3. /root/src/moduleB.d.ts
      4. 
-
    4. /root/src/moduleB/package.json ("types" 프로퍼티 지정)
      5. 
+
    5. /root/src/moduleB/package.json ("types" 항목을 지정했다면)
      6. 
 
    6. /root/src/moduleB/index.ts
      7. 
 
    7. /root/src/moduleB/index.tsx
      8. 
 
    8. /root/src/moduleB/index.d.ts
      9. 
 
    
-
    Node.js는 moduleB.js 파일을 찾은 다음, 적용 가능한 package.json 파일을 찾아 index.js 파일을 찾습니다.
    
-
    마찬가지로 비-상대적인 import에서는 Node.js 해석 로직을 따르고 먼저 파일을 검색한 다음 적용 가능한 폴더를 찾습니다.
    따라서 소스 파일 /root/src/moduleA.ts에서  import { b } from "moduleB"는 다음과 같은 조회를 하게 됩니다:
    
+
    Node.js가 moduleB.js 파일을 찾고 나서, 해당하는 package.json을 찾고, index.js를 찾았다는 것을 상기해봅시다.
    
+
    비슷하게, 비-상대적 import는 Node.js 해석 로직을 따릅니다, 첫 번째로 파일을 찾고, 그러고 나서 해당하는 폴더를 찾습니다.
+그래서 /root/src/moduleA.ts 소스 파일 안에 import { b } from "moduleB"는 다음과 같은 조회를 합니다.
    
 
      
 
    1. /root/src/node_modules/moduleB.ts
      2. 
 
    2. /root/src/node_modules/moduleB.tsx
      3. 
 
    3. /root/src/node_modules/moduleB.d.ts
      4. 
-
    4. /root/src/node_modules/moduleB/package.json ("types" 프로퍼티 지정)
      5. 
+
    5. /root/src/node_modules/moduleB/package.json ("types" 프로퍼티를 지정했다면)
      6. 
+
    6. /root/src/node_modules/@types/moduleB.d.ts
      7. 
 
    7. /root/src/node_modules/moduleB/index.ts
      8. 
 
    8. /root/src/node_modules/moduleB/index.tsx
      9. 
 
    9. /root/src/node_modules/moduleB/index.d.ts
@@ -815,7 +891,8 @@ 
      /node_modules/moduleB.ts
      10. 
 
    10. /node_modules/moduleB.tsx
      11. 
 
    11. /node_modules/moduleB.d.ts
      12. 
-
    12. /node_modules/moduleB/package.json ("types" 프로퍼티 지정)
      13. 
+
    13. /node_modules/moduleB/package.json ("types" 항목을 지정했다면)
      14. 
+
    14. /node_modules/@types/moduleB.d.ts
      15. 
 
    15. /node_modules/moduleB/index.ts
      16. 
 
    16. /node_modules/moduleB/index.tsx
      17. 
 
    17. /node_modules/moduleB/index.d.ts
      18. 
 
    
-
    단계의 수에 겁먹지마세요 - TypeScript는 여전히 단계 (8)과 (15)에서 디렉토리를 두 번 점프합니다.
    이것은 정말로 Node.js보다 복잡하지 않습니다.
    
-
    추가적인 모듈 해석 알리기 (Additional module resolution flags)
    
-
    프로젝트 소스 레이아웃이 출력 결과와 일치하지 않는 경우가 있습니다.
    일반적으로 일련의 빌드 단계의 집합에서 최종 출력을 생성합니다.
    여기에는 .ts 파일을 .js로 컴파일하는 것과 다른 소스 위치의 의존성을 하나의 출력 위치에 복사하는 것이 포함됩니다.
    최종적으로 런타임에 모듈의 이름이 정의를 포함하는 소스 파일과 다를 수 있다는 것입니다.
    또는 최종 출력의 모듈 경로가 컴파일 시 해당 소스 파일 경로와 일치하지 않을 수 있습니다.
    
-
    TypeScript 컴파일러에는 최종 출력을 생성하기 위해 소스에 발생할 것으로 예상되는 변환의 컴파일러에 정보를 제공하기 위한 추가적인 것들이 있습니다.
    
-
    컴파일러가 이러한 변환을 하지 않을 것을 주목하는 것이 중요합니다.
    이 정보를 사용하여 모듈 import를 정의 파일로 해석하는 프로세스를 안내합니다.
    
-
    Base URL
    
-
    baseUrl을 사용하는 것은 모듈이 런타임에 단일 폴더로 "배포"되는 AMD 모듈 로더를 사용하는 어플리케이션에서의 일반적인 방법입니다.
    이러한 모듈의 소스는 서로 다른 디렉토리에 존재할 수 있지만 빌드 스크립트에 의해 모두 결합되어 구성됩니다. 
    
-
    baseUrl을 설정하면 컴파일러에게 어디에서 모듈을 찾을 수 있는지 알려줍니다.
    비-상대적 이름을 가진 모든 모듈 imports는 baseUrl에 상대적인 것으로 가정됩니다.
    
-
    baseUrl 값은 다음 중 하나로 결정됩니다:
    
+
    스텝 수 때문에 두려워하지 마세요 - TypeScript가 여전히 디렉터리를 (9)와 (17)에서 두 번 점프합니다.
    
+
    Node.js가 하는 것보다 더 복잡하지 않습니다.
    
+
    추가 모듈 해석 플래그 (Additional module resolution flags)
    
+
    프로젝트 소스 레이아웃이 출력과 일치하지 않을 때도 있습니다.
+일반적으로 일련의 빌드 스텝이 생성된 최종 출력을 만듭니다.
+.ts파일을 .js로 컴파일하고, 다른 소스 위치에서 하나의 출력 위치로 의존성을 복사하는 것을 포함합니다.
+최종 결과는 런타임의 모듈이 해당 정의를 포함하는 소스 파일과 다른 이름을 가질 수 있다는 것이다.
+혹은 최종 출력의 모듈 경로가 컴파일 타임에 해당하는 소스 파일 경로와 일치하지 않을 수 있습니다.
    
+
    TypeScript 컴파일러는 추가 플래그를 갖고 있습니다.
+The TypeScript compiler has a set of additional flags to inform the compiler of transformations that are expected to happen to the sources to generate the final output.
+TypeScript 컴파일러는 최종 출력을 생성하기위해 소스에 발생할 것으로 예상되는 변환을 컴파일러에게 알리기 위한 추가 플래그 세트가 있습니다.
    
+
    컴파일러가 이러한 변환도 수행하지 않는 다는 것에 유의하십시오;
+정의 파일로 모듈 import를 해석하는 과정을 안내하기 위해 이러한 정보를 사용합니다.
    
+
    기본 URL (Base URL)
    
+
    baseUrl을 사용하는 것은 모듈들이 런타임에 단일 폴더로 "배포"되는 AMD 모듈 로더를 사용하는 애플리케이션에서 일반적인 방법입니다.
+이 모듈들의 소스는 다른 디렉터리 안에 있을 수 있지만, 빌드 스크립트가 모두 하나로 만들 것입니다.
    
+
    baseUrl을 설정하는 것은 컴파일러에게 어디에서 모듈을 찾을지 알려주는 것입니다.
+모든 비-상대적 이름의 모듈 import는 baseUrl에 상대적이라고 가정합니다.
    
+
    baseUrl의 값은 다음 중 하나로 결정됩니다:
    
 
      
-
    • baseUrl 커멘드 라인 인수의 값 (주어진 경로가 상대 경로인 경우 현재의 디렉토리의 위치를 기반으로 계산)
      • 
-
    • 'tsconfig.json'의 baseUrl 프로퍼티 값 (주어진 경로가 상대 경로인 경우 'tsconfig.json'의 위치를 기반으로 계산)
      • 
+
    • baseUrl 명령 줄 인수 값 (만약 주어진 경로가 상대적이면, 현재 디렉터리를 기준으로 계산됨)
      • 
+
    • 'tsconfig.json'안에 baseUrl 프로퍼티 값 (만약 주어진 경로가 상대적이면, 'tsconfig.json'의 위치를 기준으로 계산됨)
      • 
 
    
-
    상대적 모듈 imports는 baseUrl을 설정하면 영향을 받지 않으며 imports 파일과 관련하여 항상 확인되므로 주의해야합니다.
    
-
    RequireJS 및 SystemJS 문서에서 baseUrl에 대한 자세한 설명을 볼 수 있습니다.
    
+
    상대적 모듈 import는 항상 가져온 파일의 상대적으로 해석되기 때문에, baseUrl을 설정하는 것에 영향을 받지 않는 점에 유의하십시오.
    
+
    baseUrl에 대한 더 많은 문서는 RequireJS와 SystemJS 문서에서 찾으실 수 있습니다.
    
 
    경로 매핑 (Path mapping)
    
-
    때때로 모듈은 baseUrl 아래에 직접 위치하지 않습니다.
    예를 들어, 모듈 "jquery"에 대한 import는 런타임시에 "node_modules/jquery/dist/jquery.slim.min.js"로 변환됩니다.
    로더는 매핑 구성을 사용하여 런타임에 모듈 이름을 파일에 매핑 합니다. 자세한 내용은 RequireJs 문서와 SystemJS 문서를 참조하세요.  
    
-
    TypeScript 컴파일러는 tsconfig.json파일에서 "paths" 프로퍼티를  사용하여 이러한 매핑을 선언하는 기능을 지원합니다.
    다음은 jquery에 대한 "paths" 프로퍼티를 지정하는 예제입니다.
    
+
    가끔 모듈이 baseUrl 아래에 위치하지 않는 경우가 있습니다.
+예를 들어, "jquery" 모듈의 import는 런타임에 "node_modules/jquery/dist/jquery.slim.min.js"로 번역됩니다.
+로더는 런타임에 모듈 이름을 파일에 매핑하기 위해 매핑 구성을 사용합니다, RequireJs 문서와 SystemJS 문서를 보세요.
    
+
    TypeScript 컴파일러는 tsconfig.json 파일 안에 "paths" 프로퍼티를 사용한 매핑의 선언을 지원합니다.
+jquery를 위한 "paths" 프로퍼티를 지정하는 방법에 대한 예제가 있습니다.
    
 
    {
   "compilerOptions": {
-    "baseUrl": ".", // "paths"가 지정된 경우 이 값을 지정해야합니다.
+    "baseUrl": ".", // "paths"가 있는 경우 반드시 지정되어야함.
     "paths": {
-      "jquery": ["node_modules/jquery/dist/jquery"] // 이 매핑은 "baseUrl"과 상대적입니다.
+      "jquery": ["node_modules/jquery/dist/jquery"] // 이 매핑은 "baseUrl"에 상대적임.
     }
   }
 }
 
    
-
    "paths"는 "baseUrl"에 비례해서 해석된다는 것을 주의하십시오.
    "baseUrl"을 "."보다 다른 값으로 설정할 때 즉 tsconfig.json의 디렉토리일때마다 매핑을 적절하게 변경해야합니다.
    가령 위의 예제에서 "baseUrl": "./src"를 설정하면 jquery는 "../node_modules/jquery/dist/jquery"에 매핑되어야합니다.
    
-
    "paths"를 사용하면 여러개의 fall back 위치를 포함한 좀 더 정교한 매핑을 사용할 수도 있습니다.
    한 위치에서는 일부 모듈만 사용할 수 있고 나머지는 다른 위치에 있는 프로젝트 구성을 고려해보세요.
    빌드 단계는 모든 것을 한 곳에 한 곳에 모일 것입니다.  
    
-
    프로젝트 레이아웃은 다음과 같을 수 있습니다:
    
+
    "paths"가 "baseUrl"에 상대적으로 해석된다는 점에 주목하세요.
+"baseUrl"을 "."가 아닌 다른 값, 예 tsconfig.json의 디렉터리,으로 설정하면, 그에 따라 매핑도 바뀝니다.
+위 예제에서 "baseUrl": "./src"로 설정했기 때문에, jquery는 "../node_modules/jquery/dist/jquery"로 매핑됩니다.
    
+
    "paths"를 사용하는 것은 여러 개의 이전 위치를 포함한 정교한 매핑이 가능합니다.
+일부 모듈만 한 위치에서 사용 가능하고, 나머지는 다른 곳에 있는 프로젝트 구성을 생각해보세요.
+빌드 스텝이 한곳으로 모을 것입니다.
+프로젝트의 레이아웃은 다음과 같이 보입니다:
    
 
    projectRoot
 ├── folder1
 │   ├── file1.ts (imports 'folder1/file2' and 'folder2/file3')
@@ -868,7 +963,7 @@ 
    경로 매
 │       └── file3.ts
 └── tsconfig.json
 
    
-
    해당 tsconfig.json은 다음과 같습니다:
    
+
    tsconfig.json는 다음과 같이 보일 것입니다:
    
 
    {
   "compilerOptions": {
     "baseUrl": ".",
@@ -881,35 +976,35 @@ 
    경로 매
   }
 }
 
    
-
    이것은 "*"(모든 값) 패턴과 일치하는 모듈 import를 컴파일러에게 알려줌으로써 두 위치를 살펴봅니다:
    
+
    이는 컴파일러에게 두 위치에서 패턴 "*" (i.e. 모든 값) 과 일치하는 모든 모듈 import를 알려줍니다
    
 
      
-
    1. "*": 변경되지 않은 동일한 이름을 의미하기때문에 <moduleName> => <baseUrl>/<moduleName>을 매핑하세요.
      2. 
-
    2. "generated/*" 추가된 접두어 "generated"가 붙은 모듈 이름을 의미하기때문에 <moduleName> => <baseUrl>/generated/<moduleName>을 매핑하세요.
      3. 
+
    3. "*": 같은 이름은 바뀌지 않음을 의미, 그래서 <moduleName> => <baseUrl>/<moduleName>으로 매핑
      4. 
+
    4. "generated/*" 접두사 "generated"가 추가된 모듈 이름을 의미, 그래서 <moduleName> => <baseUrl>/generated/<moduleName>로 매핑
      5. 
 
    
-
    이 로직에 따라 컴파일러는 두 가지 imports를 다음과 같이 해석하기위해 노력합니다:
    
-
      
-
    • import 'folder1/file2'
        
-
      1. '*' 패턴이 일치하고 와일드 카드가 전체 모듈 이름을 캡처합니다.
        2. 
-
      2. 먼저 목록에 대체를 시도하세요: '*' -> folder1/file2
        3. 
-
      3. 이에 따른 대체 결과는 비상대적인 이름입니다 - baseUrl 와 결합하세요 -> projectRoot/folder1/file2.ts.
        4. 
-
      4. 좋아요. 파일이 존재합니다.
        5. 
+
        이 로직을 따르면, 컴파일러는 다음과 같은 두 가지 import를 해석하려고 할 것입니다:
        
+
        import 'folder1/file2':
        
+
          
+
        1. 모듈 '*'은 일치하고 와일드카드가 전체 모듈 이름을 캡처함
          2. 
+
        2. 목록에서 첫 번째 대체 시도: '*' -> folder1/file2
          3. 
+
        3. 대체의 결과가 비-상대적 이름 - baseUrl과 결합 -> projectRoot/folder1/file2.ts
          4. 
+
        4. 파일이 존재. 완료.
          5. 
 
        
-
-
      5. import 'folder2/file3'
          
-
        1. '*' 패턴이 일치하고 와일드 카드가 전체 모듈 이름을 캡처합니다.
          2. 
-
        2. 먼저 목록에 대체를 시도하세요: '*' -> folder2/file3
          3. 
-
        3. 이에 따른 대체 결과는 비-상대적인 이름입니다 - baseUrl 와 결합하세요 -> projectRoot/folder2/file3.ts.
          4. 
-
        4. 파일이 존재하지 않습니다. 두번째 대체 파일로 이동하세요.
          5. 
-
        5. 두번째 대체 'generated/*' -> generated/folder2/file3
          6. 
-
        6. 이에 따른 대체 결과는 비-상대적인 이름입니다 - baseUrl 와 결합하세요 -> projectRoot/generated/folder2/file3.ts.
          7. 
-
        7. 좋아요. 파일이 존재합니다.
          8. 
+
          import 'folder2/file3':
          
+
            
+
          1. 모듈 '*'은 일치하고 와일드카드가 전체 모듈 이름을 캡처함
            2. 
+
          2. 목록에서 첫 번째 대체 시도: '*' -> folder2/file3
            3. 
+
          3. 대체의 결과가 비-상대적 이름 - baseUrl과 결합 -> projectRoot/folder2/file3.ts
            4. 
+
          4. 파일이 존재하지 않음, 두 번째 대체로 이동
            5. 
+
          5. 두 번째 대체 'generated/*' -> generated/folder2/file3
            6. 
+
          6. 대체의 결과가 비-상대적 이름 - baseUrl과 결합 -> projectRoot/generated/folder2/file3.ts
            7. 
+
          7. 파일이 존재. 완료.
            8. 
 
          
-
-
    
-
    rootDirs 디렉토리 (Virtual Directories with rootDirs)
    
-
    컴파일 시 여러 디렉토리의 프로젝트 소스가 모두 결합되어 단일 출력 디렉토리를 생성하는 경우가 있습니다.
    이것은 소스 디렉토리가 "가상" 디렉토리를 만드는 것으로 볼 수 있습니다.
    
-
    rootDirs를 사용하면 "가상" 디렉토리를 구성하는 roots를 컴파일러에 알릴 수 있습니다.
    따라서 컴파일러는 이러한 "가상" 디렉토리내의 상대 모듈 imports를 하나의 디렉토리에 병합된 것처럼 해석 할 수 있습니다.
    
-
    예를 들어 다음 프로젝트 구조를 고려해보세요.
    
+
    rootDirs 가상 디렉터리 (Virtual Directories with rootDirs)
    
+
    때때로 컴파일 타임에 여러 디렉터리의 프로젝트 소스가 모두 결합되어 단일 출력 디렉터리를 생성합니다.
+여러 소스 디렉터리가 "가상" 디렉터리를 생성하는 것으로 보입니다.
    
+
    'rootDirs'를 사용하면, 컴파일러에게 이 "가상" 디렉터리를 구성하는 roots를 알릴 수 있습니다;
+따라서 컴파일러는 이러한 "가상"디렉터리 내에서 상대적 모듈 import를 마치 하나의 디렉터리에 같이 병합 한 것처럼 해석할 수 있습니다.
    
+
    예를 들어 이 프로젝트 구조를 생각해보세요:
    
 
     src
  └── views
      └── view1.ts (imports './template1')
@@ -920,8 +1015,13 @@ 
    {
   "compilerOptions": {
     "rootDirs": [
@@ -931,18 +1031,16 @@ 
    export default [
     "您好吗",
     "很高兴认识你"
 ];
 
    
-
    rootDirs를 활용하여 디렉토리가 존재하지 않더라도 이 매핑의 컴파일러에 이를 알려 줌으로써 ./#{locale}/messages를 안전하게 해결할 수 있습니다.
    
-
    예를 들어, 다음과 같은 tsconfig.json을 함께 사용합니다:
    
+
    rootDirs를 활용하여 컴파일러에게 이 매핑에 대해 알려주어 심지어 디렉터리가 존재하지 않아도 안전하게 ./#{locale}/messages를 해석할 수 있도록 합니다. 예를 들어, 다음과 같은 tsconfig.json를 보십시오:
    
 
    {
   "compilerOptions": {
     "rootDirs": [
@@ -953,10 +1051,13 @@ 
    모듈 해석 추적 (Tracing module resolution)
    
-
    앞에서 설명한 것처럼 컴파일러가 모듈을 해석할 때 현재 폴더 외부의 파일들에 방문할 수 있습니다.
    모듈이 해석되지 않은 이유를 진단하거나 잘못된 정의로 해석된 경우에는  문제 해석이 어려울 수 있습니다.
    --traceResolution을 사용하여 컴파일러 모듈 해석 추적을 활성화하면 모듈 확인 프로세스 중에 발생한 일에 대한 통찰력을 얻을 수 있습니다.
    
-
    typescript 모듈을 사용하는 샘플 애플리케이션이 있다고 가정해 봅시다.
    app.ts는 import * as ts from "typescript"와 같은 import를 가지고 있습니다.
    
+
    앞에서 논의한 바와 같이 컴파일러는 모듈을 해석할 때 현재 폴더 외부의 파일을 방문할 수 있습니다.
+이는 모듈이 해석되지 않거나 잘못된 정의로 해석된 이유를 진단할 때 어려울 수 있습니다.
+'--traceResolution'을 사용하여 컴파일러 모듈 해석 추적을 활성화하면 모듈 해석 과정 중에 발생한 작업에 대한 인사이트를 얻을 수 있습니다.
    
+
    typescript 모듈을 사용하는 예제 애플리케이션이 있다고 해봅시다.
+app.ts는 import * as ts from "typescript" 같은 import가 있습니다.
    
 
    │   tsconfig.json
 ├───node_modules
 │   └───typescript
@@ -965,10 +1066,10 @@ 
    tsc --traceResolution
 
    
-
    결과는 다음과 같습니다:
    
+
    다음과 같은 출력이 발생:
    
 
    ======== Resolving module 'typescript' from 'src/app.ts'. ========
 Module resolution kind is not specified, using 'NodeJs'.
 Loading module 'typescript' from 'node_modules' folder.
@@ -988,45 +1089,51 @@ 
    주의
 
      
 
    • import의 이름과 위치
      
 
      
-
      ======== 모듈 해석 'typescript' from 'src/app.ts'. ========
      
+
      ======== 'src/app.ts' 에서 'typesciprt' 모듈 해석. ========
      
 
      
 
      • 
-
    • 컴파일러가 따르는 방법
      
+
    • 컴파일러가 따르는 전략
      
 
      
-
      'NodeJs' 를 사용하여 모듈 해석 종류가 지정되지 않았습니다.
      
+
      모듈 해석 종류가 지정되지 않으면, 'NodeJs 사용.
      
 
      
 
      • 
-
    • npm 패키지에서 타입 로드
      
+
    • npm 패키지에서 types 로딩
      
 
      
-
      'package.json'에는 'node_modules/typescript/lib/typescript.d.ts'를 참조하는 'types' 필드인 './lib/typescript.d.ts'가 있습니다.
      
+
      'package.json'은 'node_modules/typescript/lib/typescript.d.ts'를 참조하는 'types' 필드 './lib/typescript.d.ts'가 있습니다.
      
 
      
 
      • 
 
    • 최종 결과
      
 
      
-
      ======== 모듈 이름 'typescript'는 'node_modules/typescript/lib/typescript.d.ts'에서 성공적으로 해석되었습니다. ========
      
+
      ======== 모듈 이름 'typescript'는 'node_modules/typescript/lib/typescript.d.ts'로 성공적으로 해석 되었습니다. ========
      
 
      
 
      • 
 
    
 
    --noResolve 사용하기 (Using --noResolve)
    
-
    일반적으로 컴파일러는 컴파일 프로세스를 시작하기 전에 모든 모듈의 imports를 해석하려고 시도합니다.
    파일에 import를 성공적으로 해석할 때마다 컴파일러는 파일을 나중에 처리할 파일 집합에 추가합니다.
    
-
    --noResolve 컴파일러 옵션은 컴파일러가 커맨드라인에서 전달되지 않은 파일을 컴파일에 "추가"하지 않도록 지시합니다.
    모듈을 파일로 해석하려고 하지만 파일이 지정되지 않으면 포함되지 않습니다.
    
+
    일반적으로 컴파일러는 컴파일 과정을 시작하기 전에 모든 모듈 import를 해석하려고 합니다.
+파일의 import를 성공적으로 해석할 때마다, 파일은 나중에 컴파일러가 처리할 파일 세트에 추가됩니다.
    
+
    --noResolve 컴파일러 옵션은 명령 줄에 전달하지 않은 파일은 컴파일에 "추가" 하지 않도록 지시합니다.
+여전히 파일에 모듈을 해석하려고 하지만, 파일이 지정되지 않았으면, 그 파일은 포함하지 않습니다.
    
 
    예를 들어:
    
 
    app.ts
    
-
    import * as A from "moduleA" // 좋아요, 'moduleA'가 커맨드라인에서 전달되었습니다.
-import * as B from "moduleB" // TS2307 오류: 'moduleB' 모듈을 찾을 수 없습니다.
+
    import * as A from "moduleA" // 성공, 'moduleA'가 명령줄로 전달됨
+import * as B from "moduleB" // Error TS2307: Cannot find module 'moduleB.
 
    
 
    tsc app.ts moduleA.ts --noResolve
 
    
-
    --noResolve를 사용하여 app.ts를 컴파일하면 다음과 같은 결과가 발생합니다:
    
+
    --noResolve를 사용한 app.ts의 컴파일은 다음과 같은 결과가 나옵니다:
    
 
      
-
    • 커맨드라인에서 전달된대로 moduleA를 적절하게 찾습니다.
      • 
-
    • 전달되지 않았기 때문에 moduleB를 찾지 못하는 오류.
      • 
+
    • 명령 줄로 전달했기 때문에 moduleA는 정확하게 찾음.
      • 
+
    • 전달하지 않았기 때문에 moduleB를 찾는데 실패함.
      • 
 
    
 
    공통 질문 (Common Questions)
    
-
    제외 목록에 있는 모듈을 여전히 컴파일러가 선택하는 이유는 무엇입니까? (Why does a module in the exclude list still get picked up by the compiler?)
    
-
    tsconfig.json은 폴더를 "프로젝트"로 만듭니다.
    “exclude” 또는 “files” 항목을 지정하지 않으면 tsconfig.json을 포함한 폴더의 모든 파일과 해당 하위 디렉토리가 컴파일에 포함됩니다.
    일부 파일을 제외하려면 “exclude”를 사용하세요.
    만일 모든 파일을 지정하고 싶다면 컴파일러가 찾아보게 하는 대신에 “files”을 사용하세요.
    
-
    tsconfig.json는 자동 포함입니다.
    위에서 설명한 모듈 해석을 포함하지 않습니다.
    컴파일러가 파일을 모듈 import의 대상으로 식별하는 경우 이전 단계에서 제외되었는지 여부에 관계 없이 컴파일에 포함됩니다.
    
-
    따라서 컴파일에서 파일을 제외하려면 import 또는 /// <reference path="..." /> 지시자가 있는 모든 파일을 제외해야 합니다.
    
+
    제외 목록에 있는 모듈을 여전히 컴파일러가 선택하는 이유는 무엇인가? (Why does a module in the exclude list still get picked up by the compiler?)
    
+
    tsconfig.json은 폴더를 "프로젝트"로 바꿉니다.
+"exclude" 나 "files" 엔트리를 지정하지 않으면, tsconfig.json를 포함하는 폴더 안의 모든 파일과 모든 하위-디렉터리가 컴파일에 포함됩니다.
+만약 일부 파일을 제외하고 싶으면 "exclude"를 사용하고, 컴파일러가 찾도록 하게 하는 대신 모든 파일을 지정하고 싶으면, "files"를 사용하십시오.
    
+
    tsconfig.json의 자동 포함입니다.
+위에서 논의한 내장 모듈 해석이 아닙니다.
+컴파일러는 파일을 모듈 import 대상으로 식별한 경우, 이전 단계에서 제외되었는지에 관계없이 컴파일에 포함하게 됩니다.
    
+
    그래서 컴파일에 파일은 제외하기 위해서는, 그 파일을 제외하고 그 파일에 import나 /// <reference path="..."" /> 지시문이 있는 모든 파일을 제외해야 합니다.
    
 
                                 
                                 
    
@@ -1070,7 +1177,7 @@ 
    No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"모듈 해석","level":"3.16","depth":1,"next":{"title":"선언 병합","level":"3.17","depth":1,"path":"pages/Declaration Merging.md","ref":"pages/Declaration Merging.md","articles":[]},"previous":{"title":"네임스페이스와 모듈","level":"3.15","depth":1,"path":"pages/Namespaces and Modules.md","ref":"pages/Namespaces and Modules.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Module Resolution.md","mtime":"2019-06-14T05:32:52.245Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"모듈 해석","level":"3.16","depth":1,"next":{"title":"선언 병합","level":"3.17","depth":1,"path":"pages/Declaration Merging.md","ref":"pages/Declaration Merging.md","articles":[]},"previous":{"title":"네임스페이스와 모듈","level":"3.15","depth":1,"path":"pages/Namespaces and Modules.md","ref":"pages/Namespaces and Modules.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Module Resolution.md","mtime":"2020-04-22T15:29:36.176Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Modules.html b/pages/Modules.html
index 3049f469..06980a18 100644
--- a/pages/Modules.html
+++ b/pages/Modules.html
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
    • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
  • 
+        
  • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
    • 
+    
+        
  • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
  • 릴리즈 노트
    • 
+        
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
    • 
+    
+
+    
 
     
  • 
 
@@ -711,27 +757,28 @@ 
    
     
                                 
    
                                 
-                                
    
-
    용어에 대한 참고 사항:
-TypeScript 1.5에서는 명칭이 변경되었습니다.
    "내부(Internal) 모듈"은 이제 "네임스페이스"입니다.
    "외부(External) 모듈"은 이제 ECMAScript 2015의 용어에 맞게  간단히 "모듈"입니다
-(즉 모듈 X { 는 현재 선호되는 네임스페이스 X { 와 동일합니다).
    
-
    
-
    소개
    
+                                
    소개 (Introduction)
    
 
    ECMAScript 2015부터 JavaScript에는 모듈 개념이 있습니다. TypeScript는 이 개념을 공유합니다.
    
-
    모듈은 전역 스코프가 아닌 자체 스코프 내에서 실행됩니다.
    이는 export 형식 중 하나를 사용하여 명시적으로 내보내지 않는 한 모듈에 선언된 변수, 함수, 클래스 등이 모듈 외부에 보이지 않는다는 것을 의미합니다.
    반대로 다른 모듈에서 내보낸 변수, 함수, 클래스, 인터페이스 등을 사용하려면 import 형식 중 하나를 사용하여 가져와야 합니다.  
    
-
    모듈은 선언적입니다. 모듈 간의 관계는 파일 수준에서 imports 및 exports 측면에서 지정됩니다.
    
-
    모듈은 모듈 로더를 사용하여 또 다른 모듈을 import 합니다.
    런타임시 모듈 로더는 모듈을 실행하기 전에 모듈의 모든 의존성을 찾고 실행합니다.
    JavaScript에서 사용되는 잘 알려진 모듈 로더는 Node.js의 CommonJS모듈 로더이며 웹 애플리케이션의 경우 require.js입니다.
    
-
    TypeScript에서는 ECMAScript 2015와 마찬가지로 최상위 import 또는 export가 포함된 파일을 모듈로 간주합니다.
    
-
    내보내기 (Export)
    
-
    내보내기 선언 (Exporting a declaration)
    
-
    변수, 함수, 클래스, 타입 별칭(alias) 또는 인터페이스와 같은 선언문은 export 키워드를 추가하여 내보낼 수 있습니다.
    
-
    Validation.ts
    
+
    모듈은 전역 스코프가 아닌 자체 스코프 내에서 실행됩니다; 즉 모듈 내에서 선언된 변수, 함수, 클래스 등은 export 양식 중 하나를 사용하여 명시적으로 export 하지 않는 한 모듈 외부에서 보이지 않습니다.
+반대로 다른 모듈에서 export 한 변수, 함수, 클래스, 인터페이스 등을 사용하기 위해서는 import 양식 중 하나를 사용하여 import 해야 합니다.
    
+
    모듈은 선언형입니다; 모듈 간의 관계는 파일 수준의 imports 및 exports 관점에서 지정됩니다.
    
+
    모듈은 모듈 로더를 사용하여 다른 모듈을 import 합니다.
+런타임 시 모듈 로더는 모듈을 실행하기 전에 모듈의 모든 의존성을 찾고 실행해야 합니다.
+JavaScript에서 사용하는 유명한 모듈 로더로는 CommonJS 모듈 용 Node.js의 로더와 웹 애플리케이션의 AMD 모듈 용 RequireJS 로더가 있습니다.
    
+
    ECMAScript 2015와 마찬가지로 TypeScript는 최상위 수준의 import 혹은 export가 포함된 모든 파일을 모듈로 간주합니다.
+반대로 최상위 수준의 import 혹은 export 선언이 없는 파일은 전역 스코프에서 사용할 수 있는 스크립트로 처리됩니다(모듈에서도 마찬가지).
    
+
    Export
    
+
    선언 export 하기 (Exporting a declaration)
    
+
    export 키워드를 추가하여 모든 선언 (변수, 함수, 클래스, 타입 별칭, 인터페이스)를 export 할 수 있습니다.
    
+
    StringValidator.ts
    
 
    export interface StringValidator {
     isAcceptable(s: string): boolean;
 }
 
    
 
    ZipCodeValidator.ts
    
-
    export const numberRegexp = /^[0-9]+$/;
+
    import { StringValidator } from "./StringValidator";
+
+export const numberRegexp = /^[0-9]+$/;
 
 export class ZipCodeValidator implements StringValidator {
     isAcceptable(s: string) {
@@ -739,8 +786,8 @@ 
    ZipCodeValidator.ts
    
     }
 }
 
    
-
    내보내기 문 (Export statements)
    
-
    Export 문은 사용자를 위해 Export의 이름을 변경해야 하는 경우에 유용하므로 위의 예제를 다음과 같이 작성할 수 있습니다:
    
+
    Export 문 (Export statements)
    
+
    Export 문은 사용자를 위해 export 할 이름을 바꿔야 할 때 편리합니다. 위의 예제는 다음과 같이 작성할 수 있습니다:
    
 
    class ZipCodeValidator implements StringValidator {
     isAcceptable(s: string) {
         return s.length === 5 && numberRegexp.test(s);
@@ -749,8 +796,9 @@ 
    내&#x
 export { ZipCodeValidator };
 export { ZipCodeValidator as mainValidator };
 
    
-
    다시 내보내기 (Re-exports)
    
-
    종종 모듈은 다른 모듈을 확장하고 일부 기능을 부분적으로 노출합니다.
    다시 내보내기(re-export)는 로컬로 import하거나 로컬 변수를 도입하지 않습니다.
    
+
    Re-export 하기 (Re-exports)
    
+
    종종 모듈은 다른 모듈을 확장하고 일부 기능을 부분적으로 노출합니다.
+Re-export 하기는 지역적으로 import 하거나, 지역 변수를 도입하지 않습니다.
    
 
    ParseIntBasedZipCodeValidator.ts
    
 
    export class ParseIntBasedZipCodeValidator {
     isAcceptable(s: string) {
@@ -758,48 +806,68 @@ 
    ParseIntBasedZipCodeValidator.ts
    
     }
 }
 
-// 원본 validator 내보내지만 이름을 변경합니다
+// 기존 validator의 이름을 변경 후 export
 export {ZipCodeValidator as RegExpBasedZipCodeValidator} from "./ZipCodeValidator";
 
    
-
    선택적으로 모듈은 하나 이상의 모듈을 감싸고 export * from "module" 구문을 사용하여 모든 export를 결합할 수 있습니다.
    
+
    선택적으로, 하나의 모듈은 하나 혹은 여러 개의 모듈을 감쌀 수 있고, export * from "module" 구문을 사용해 export 하는 것을 모두 결합할 수 있습니다.
    
 
    AllValidators.ts
    
-
    export * from "./StringValidator"; // exports interface 'StringValidator'
-export * from "./LettersOnlyValidator"; // exports class 'LettersOnlyValidator'
-export * from "./ZipCodeValidator";  // exports class 'ZipCodeValidator'
+
    export * from "./StringValidator"; // 'StringValidator' 인터페이스를 내보냄
+export * from "./ZipCodeValidator";  // 'ZipCodeValidator' 와 const 'numberRegexp' 클래스를 내보냄
+export * from "./ParseIntBasedZipCodeValidator"; // 'ParseIntBasedZipCodeValidator' 클래스를 내보냄
+                                                 // 'ZipCodeValidator.ts' 모듈 에 있는
+                                                 // 'ZipCodeValidator' 클래스를
+                                                 // 'RegExpBasedZipCodeValidator' 라는 별칭으로 다시 내보냄
 
    
 
    Import
    
-
    import는 모듈에서 export 만큼 쉽습니다.
    export 선언을 가져오려면 아래의 import 형식 중 하나를 사용하십시오.
    
-
    모듈에서 단일 내보내기 가져오기 (Import a single export from a module)
    
+
    import는 모듈에서 export 만큼 쉽습니다.
+export 한 선언은 아래의 import 양식 중 하나를 사용하여 import 합니다:
    
+
    모듈에서 단일 export를 import 하기 (Import a single export from a module)
    
 
    import { ZipCodeValidator } from "./ZipCodeValidator";
 
 let myValidator = new ZipCodeValidator();
 
    
-
    imports 이름을 변경할 수도 있습니다.
    
+
    이름을 수정해서 import 할 수 있습니다.
    
 
    import { ZipCodeValidator as ZCV } from "./ZipCodeValidator";
 let myValidator = new ZCV();
 
    
-
    전체 모듈을 단일 변수로 가져오고 이를 사용하여 모듈 내보내기에 접근하기 (Import the entire module into a single variable, and use it to access the module exports)
    
+
    전체 모듈을 단일 변수로 import 해서, 모듈 exports 접근에 사용하기 (Import the entire module into a single variable, and use it to access the module exports)
    
 
    import * as validator from "./ZipCodeValidator";
 let myValidator = new validator.ZipCodeValidator();
 
    
-
    부수 효과에 대한 모듈만 가져오기 (Import a module for side-effects only)
    
-
    권장되지는 않지만 일부 모듈은 다른 모듈에서 사용할 수 있는 글로벌 상태를 설정합니다.
    이러한 모듈에는 어떠한 exports도 없거나 사용자가 해당 exports에 관심이 없을 수 있습니다.
    
-
    이러한 모듈을 가져오려면 다음을 사용합니다:
    
-
    import "./my-module.js";
+
    부수효과만을 위해 모듈 import 하기 (Import a module for side-effects only)
    
+
    권장되지는 않지만, 일부 모듈은 다른 모듈에서 사용할 수 있도록 일부 전역 상태로 설정합니다.
+이러한 모듈은 어떤 exports도 없거나, 사용자가 exports에 관심이 없습니다.
+이러한 모듈을 import 하기 위해, 다음처럼 사용하세요:
    
+
    import "./my-module.js"
 
    
-
    기본 내보내기 (Default exports)
    
-
    각 모듈은 선택적으로 default export를 내보낼 수 있습니다.
    Default exports는 default 키워드로 표시됩니다. 모듈별 default exports는 하나만 가능합니다.
    default exports는 다른 import 형식을 사용하여 가져옵니다.
    
-
    default exports는 정말 편리합니다.
    예를 들어 JQuery 같은 라이브러리에는 default export인 jQuery 또는 $가 있을 수 있으며 이를 $나 jQuery라는 이름으로도 가져올 수 있습니다.
    
-
    JQuery.d.ts
    
+
    타입 import 하기 (Importing Types)
    
+
    TypeScript 3.8 이전에는 import를 사용하여 타입을 import 할 수 있었습니다.
+TypeScript 3.8에서는 import 문 혹은 import type을 사용하여 타입을 import 할 수 있습니다.
    
+
    // 동일한 import를 재사용하기
+import {APIResponseType} from "./api";
+
+// 명시적으로 import type을 사용하기
+import type {APIResponseType} from "./api";
+
    
+
    import type은 항상 JavaScript에서 제거되며, 바벨 같은 도구는 isolatedModules 컴파일러 플래그를 통해 코드에 대해 더 나은 가정을 할 수 있습니다.
+3.8 릴리즈 정보에서 더 많은 정보를 읽을 수 있습니다.
    
+
    Default exports
    
+
    각 모듈은 선택적으로 default export를 export 할 수 있습니다.
+default export는 default 키워드로 표시됩니다; 모듈당 하나의 default export만 가능합니다.
+default export는 다른 import 양식을 사용하여 import 합니다.
    
+
    default exports는 정말 편리합니다.
+예를 들어 jQuery와 같은 라이브러리는 jQuery 혹은 $와 같은 default export를 가질 수 있으며, $나 jQuery와 같은 이름으로 import할 수 있습니다.
    
+
    JQuery.d.ts
    
 
    declare let $: JQuery;
 export default $;
 
    
 
    App.ts
    
-
    import $ from "JQuery";
+
    import $ from "jquery";
 
 $("button.continue").html( "Next Step..." );
 
    
-
    클래스 및 함수 선언은 default exports로 직접 작성될 수 있습니다.
    Default export 클래스와 함수 선언 네이밍은 선택적입니다.
    
+
    클래스 및 함수 선언은 default exports로 직접 작성될 수 있습니다.
+default export 클래스 및 함수 선언 이름은 선택사항 입니다.
    
 
    ZipCodeValidator.ts
    
 
    export default class ZipCodeValidator {
     static numberRegexp = /^[0-9]+$/;
@@ -813,7 +881,7 @@ 
    Test.ts
    
 
 let myValidator = new validator();
 
    
-
    또는
    
+
    혹은
    
 
    StaticZipCodeValidator.ts
    
 
    const numberRegexp = /^[0-9]+$/;
 
@@ -826,12 +894,12 @@ 
    Test.ts
    
 
 let strings = ["Hello", "98052", "101"];
 
-// 함수 유효성 검사 사용
+// validate 함수 사용하기
 strings.forEach(s => {
-  console.log(`"${s}" ${validate(s) ? " matches" : " does not match"}`);
+  console.log(`"${s}" ${validate(s) ? "matches" : "does not match"}`);
 });
 
    
-
    default exports는 값 일 수도 있습니다:
    
+
    default exports는 값도 가능합니다:
    
 
    OneTwoThree.ts
    
 
    export default "123";
 
    
@@ -840,12 +908,21 @@ 
    Log.ts
    
 
 console.log(num); // "123"
 
    
-
    export = and import = require()
    
-
    CommonJS와 AMD 모두 일반적으로 모듈의 모든 exports를 포함하는 exports 객체 개념을 가지고 있습니다.
    
-
    또한 exports 객체를 커스텀 단일 객체로 대체하는 것을 지원합니다.
    Default exports는이 동작을 대신하는 역할을 합니다.
    그러나 그 둘은 호환되지 않습니다.
    TypeScript는 기존의 CommonJS와 AMD 워크플로우를 모델링하기 위해 export =를 지원합니다.
    
-
    export = 구문은 모듈에서 export된 단일 객체를 지정합니다.
-클래스, 인터페이스, 네임스페이스, 함수 또는 열거형이 될 수 있습니다.
    
-
    export =를 사용하여 모듈을 import 할 때 모듈을 import 하기 위해 TypeScript에 특정한 import module = require("module")을 사용해야합니다.
    
+
    x로 모두 export 하기 (Export all as x)
    
+
    TypeScript 3.8에서는 다음 이름이 다른 모듈로 re-export 될 때 단축어처럼 export * as ns를 사용할 수 있습니다:
    
+
    export * as utilities from "./utilities";
+
    
+
    모듈에서 모든 의존성을 가져와 export한 필드로 만들면, 다음과 같이 import할 수 있습니다:
    
+
    import { utilities } from "./index";
+
    
+
    export =와 import = require() (export = and import = require())
    
+
    CommonJS와 AMD 둘 다 일반적으로 모듈의 모든 exports를 포함하는 exports 객체의 개념을 가지고 있습니다.
    
+
    또한 exports 객체를 사용자 정의 단일 객체로 대체하는 기능도 지원합니다.
+default exports는 이 동작에서 대체 역할을 합니다; 하지만 둘은 호환되지는 않습니다.
+TypeScript는 기존의 CommonJS와 AMD 워크플로우를 모델링 하기 위해 export =를 지원합니다.
    
+
    export = 구문은 모듈에서 export되는 단일 객체를 지정합니다.
+클래스, 인터페이스, 네임스페이스, 함수 혹은 열거형이 될 수 있습니다.
    
+
    export =를 사용하여 모듈을 export할 때, TypeScript에 특정한 import module = require("module")를 사용하여 모듈을 가져와야 합니다.
    
 
    ZipCodeValidator.ts
    
 
    let numberRegexp = /^[0-9]+$/;
 class ZipCodeValidator {
@@ -864,14 +941,15 @@ 
    Test.ts
    
 // 사용할 Validators
 let validator = new zip();
 
-// 각 문자열이 각 Validator를 통과했는지 여부를 보여줍니다.
+// 각 문자열이 각 validator를 통과했는지 보여줍니다
 strings.forEach(s => {
   console.log(`"${ s }" - ${ validator.isAcceptable(s) ? "matches" : "does not match" }`);
 });
 
    
 
    모듈을 위한 코드 생성 (Code Generation for Modules)
    
-
    컴파일시 지정된 모듈 대상에 따라 컴파일러는 Node.js (CommonJS), require.js (AMD), UMD, SystemJS 또는 ECMAScript 2015 네이티브 모듈 (ES6)에 적절한 코드를 생성합니다.
    생성된 코드에서 define, require 및 register 호출에 대한 자세한 정보는 각 모듈 로더에 대한 문서를 참조하세요.
    
-
    이 간단한 예제는 import 및 export 중에 사용되는 이름이 모듈 로딩 코드로 어떻게 변환되는지 보여줍니다.
    
+
    컴파일 중에는 지정된 모듈 대상에 따라 컴파일러는 Node.js (CommonJS), require.js (AMD), UMD, SystemJS, 또는 ECMAScript 2015 native modules (ES6) 모듈-로딩 시스템에 적합한 코드를 생성합니다.
+생성된 코드의 define, require 그리고 register 호출 기능에 대한 자세한 정보는 각 모듈 로더의 문서를 확인하세요.
    
+
    이 간단한 예제는 import 및 export 하기 중에 사용된 이름이 모듈 로딩 코드로 변환되는 방법을 보여줍니다.
    
 
    SimpleModule.ts
    
 
    import m = require("mod");
 export let t = m.something + 1;
@@ -918,12 +996,13 @@ 
    Native ECMAScript 2015 mo
 export var t = something + 1;
 
    
 
    간단한 예제 (Simple Example)
    
-
    아래에서는 각 모듈에서 이름이 지정된 단일 export만 내보내도록 이전 예제에 사용된 Validator 구현을 통합했습니다.
    
-
    컴파일하려면 커맨드 라인에 모듈 대상을 지정해야 합니다.
    Node.js는 --module commonjs를 사용하세요.
    require.js의 경우 --module amd를 사용합니다.  
    
-
    예를 들어:
    
+
    아래에서는 각 모듈에서 단일 이름으로 export 하기 위해 이전 예제에서 사용한 Validator 구현을 통합합니다.
    
+
    컴파일 하려면, 명령 줄에서 모듈 대상을 지정해야 합니다. Node.js의 경우, --module commonjs를 사용하세요;
+require.js의 경우 --module amd를 사용하세요. 예를 들면:
    
 
    tsc --module commonjs Test.ts
 
    
-
    컴파일시 각 모듈은 별도의 .js 파일이 됩니다.
    참조 태그와 마찬가지로 컴파일러는 의존된 파일들을 컴파일하기 위해 import 문을 따릅니다.
    
+
    컴파일이 되면, 각 모듈은 별도의 .js파일이 됩니다.
+참조 태그와 마찬가지로, 컴파일러는 import문을 따라 의존적인 파일들을 컴파일 합니다.
    
 
    Validation.ts
    
 
    export interface StringValidator {
     isAcceptable(s: string): boolean;
@@ -959,12 +1038,12 @@ 
    Test.ts
    
 // 시험용 샘플
 let strings = ["Hello", "98052", "101"];
 
-// 사용할 Validators
+// 사용할 validator
 let validators: { [s: string]: StringValidator; } = {};
 validators["ZIP code"] = new ZipCodeValidator();
 validators["Letters only"] = new LettersOnlyValidator();
 
-// 각 문자열이 각 Validator를 통과했는지 여부를 보여줍니다.
+// 각 문자열이 validator를 통과하는지 보여줌
 strings.forEach(s => {
     for (let name in validators) {
         console.log(`"${ s }" - ${ validators[name].isAcceptable(s) ? "matches" : "does not match" } ${ name }`);
@@ -972,10 +1051,18 @@ 
    Test.ts
    
 });
 
    
 
    선택적 모듈 로딩과 기타 고급 로딩 시나리오 (Optional Module Loading and Other Advanced Loading Scenarios)
    
-
    상황에 따라 일부 조건에서만 모듈을 로드할 수 있습니다.
    TypeScript에서는 아래의 패턴을 통해 다른 고급 로드 시나리오를 구현하여 타입 안전성을 잃지 않고 모듈 로더를 직접 호출할 수 있습니다.
    컴파일러는 각 모듈이 방출된 JavaScript에서 사용되는지 여부를 감지합니다.
    모듈 식별자가 타입 어노테이션의 일부로만 사용되고 표현식으로 사용되지 않으면 해당 모듈에 대한 require 호출이 방출하지 않습니다.
    사용하지 않는 참조를 제거하면 성능이 최적화되고 해당 모듈을 선택적으로 로드할 수 있습니다.
    
-
    이 패턴의 핵심 아이디어는 import id = require("...")문이 모듈에 의해 노출된 타입에 접근할 수 있다는 것입니다.
    모듈 로더는 아래의 if 블록처럼 동적으로 (require를 통해) 호출됩니다.
    이는 참조 생략 최적화가 활용되어 모듈이 필요한 경우에만 로드됩니다.
    이 패턴이 작동하려면 import를 통해 정의된 symbol이 타입 위치에서만 사용되어야 합니다(즉 JavaScript로 방출될 수 있는 위치에 절대 존재하지 않습니다).
    
-
    타입 안전성을 유지하기 위해 typeof 키워드를 사용할 수 있습니다.
    typeof 키워드는 타입의 위치에서 사용될 때 값의 타입을 생성하며 이 경우 모듈의 타입이 됩니다.
    
-
    Node.js의 동적 모듈 로딩 (Dynamic Module Loading in Node.js)
    
+
    상황에 따라 특정 조건에서만 모듈을 로드하도록 만들 수 있습니다.
+TypeScript에서는 아래에 있는 패턴을 사용하여 이 시나리오와 다른 고급 로딩 시나리오를 구현하여 타입의 안전성을 잃지 않고 모듈 로더를 직접 호출할 수 있습니다.
    
+
    컴파일러는 노출된 JavaScript 안에서 각 모듈의 사용 여부를 감지합니다.
+모듈 식별자가 표현식이 아닌 타입 표시로만 사용된다면 그 모듈에 대한 require 호출은 발생하지 않습니다.
+사용하지 않는 참조를 제거하면 성능을 최적화할 수 있으며, 해당 모듈을 선택적으로 로딩 할 수 있습니다.
    
+
    이 패턴의 핵심 아이디어는 import id = require("...") 문을 통해 모듈로 노출된 타입에 접근이 가능하다는 것입니다.
+아래 if 블록에 보이는 것처럼, 모듈 로더는 (require을 통해) 동적으로 호출됩니다.
+이 기능은 참조-제거 최적화를 활용하므로 필요할 때만 모듈을 로드할 수 있습니다.
+해당 패턴이 동작하려면 import를 통해 정의된 심벌은 오직 타입 위치(즉, JavaScript로 방출되는 위치에서는 사용 안 함)에서만 사용되는 것이 중요합니다.
    
+
    타입 안전성을 유지하기 위해, typeof 키워드를 사용할 수 있습니다.
+typeof 키워드는 타입 위치에서 사용될 때는 값의 타입, 이 경우에는 모듈의 타입을 생성합니다.
    
+
    Node.js에서 동적 모듈 로딩 (Dynamic Module Loading in Node.js)
    
 
    declare function require(moduleName: string): any;
 
 import { ZipCodeValidator as Zip } from "./ZipCodeValidator";
@@ -986,7 +1073,7 @@ 
    if (validator.isAcceptable("...")) { /* ... */ }
 }
 
    
-
    샘플: require.js의 동적 모듈 로딩 (Dynamic Module Loading in require.js)
    
+
    샘플: require.js에서 동적 모듈 로딩 (Sample: Dynamic Module Loading in require.js)
    
 
    declare function require(moduleNames: string[], onLoad: (...args: any[]) => void): void;
 
 import * as Zip from "./ZipCodeValidator";
@@ -998,7 +1085,7 @@ 
    샘플: System.js의 동적 모듈 로딩 (Dynamic Module Loading in System.js)
    
+
    샘플: System.js에서 동적 모듈 로딩 (Sample: Dynamic Module Loading in System.js)
    
 
    declare const System: any;
 
 import { ZipCodeValidator as Zip } from "./ZipCodeValidator";
@@ -1010,15 +1097,18 @@ 
    다른 JavaScript 라이브러리 사용 (Working with Other JavaScript Libraries)
    
-
    TypeScript로 작성되지 않은 라이브러리의 형태을 설명하려면 라이브러리가 나타내는 API를 선언해야 합니다.
    
-
    구현을 "ambient"으로 정의하지 않는 선언이라고 하며 
-일반적으로 이들은 .d.ts 파일에 정의되어 있습니다.
    C/C++에 익숙하다면 이것들을 .h파일로 생각할 수 있을 것입니다.
    
-
    몇 가지 예를 들어보겠습니다
    
-
    Ambient Modules
    
-
    Node.js에서 대부분의 작업은 하나 이상의 모듈을 로드하여 수행됩니다.
    각 모듈을 .d.ts 파일에 최상위 수준의 내보내기 선언으로 정의할 수 있지만 더 넓은 .d.ts 파일로 작성하는 것이 더 편리합니다.
    그렇게하기 위해서 ambient 네임스페이스와 비슷한 구조를 사용하지만 나중에 import 할 수 있는 모듈의 module 키워드와 따옴표 붙은 이름을 사용합니다.
    
-
    예를 들어:
    
-
    node.d.ts (simplified excerpt)
    
+
    다른 JavaScript 라이브러리와 함께 사용하기 (Working with Other JavaScript Libraries)
    
+
    TypeScript로 작성되지 않은 라이브러리의 형태를 설명하려면, 라이브러리를 노출하는 API를 선언해야 합니다.
    
+
    우리는 구현을 정의하지 않은 선언을 "ambient"라고 부릅니다.
+이 선언들은 일반적으로 .d.ts 파일에 정의되어 있습니다.
+C/C++에 익숙하다면, .h 파일이라고 생각할 수 있습니다.
+몇 가지 예제를 살펴보겠습니다.
    
+
    Ambient 모듈 (Ambient Modules)
    
+
    Node.js에서는 대부분의 작업은 하나 이상의 모듈을 로드하여 수행합니다.
+최상위-레벨의 내보내기 선언으로 각 모듈을 .d.ts 파일로 정의할 수 있지만, 더 큰 하나의 .d.ts 파일로 모듈들을 작성하는 것이 더 편리합니다.
+이를 위해, ambient 네임스페이스와 유사한 구조를 사용하지만, 나중에 import 할 수 있는 인용된 모듈 이름과 module 키워드를 사용합니다.
+예를 들면:
    
+
    node.d.ts (간단한 발췌)
    
 
    declare module "url" {
     export interface Url {
         protocol?: string;
@@ -1035,61 +1125,72 @@ 
    node.d.ts (simplified excerpt)
    
     export var sep: string;
 }
 
    
-
    이제 /// <reference> node.d.ts 를 만들 수 있고 import url = require("url"); 또는 import * as URL from "url"
-를 사용하여 모듈을 적재할 수 있습니다.
    
+
    이제 /// <reference> node.d.ts를 수행한 다음, import url = require("url"); 또는 import * as URL from "url"을 사용하여 모듈을 로드할 수 있습니다.
    
 
    /// <reference path="node.d.ts"/>
 import * as URL from "url";
 let myUrl = URL.parse("http://www.typescriptlang.org");
 
    
-
    Shorthand ambient modules
    
-
    새로운 모듈을 사용하기 전에 선언을 작성하는 시간을 내고 싶지 않다면 shorthand 선언을 사용하여 빠르게 시작할 수 있습니다.
    
+
    속기 ambient 모듈 (Shorthand ambient modules)
    
+
    새로운 모듈을 사용하기 전에 선언을 작성하지 않는 경우, 속기 선언(shorthand declaration)을 사용하여 빠르게 시작할 수 있습니다.
    
 
    declarations.d.ts
    
 
    declare module "hot-new-module";
 
    
-
    shorthand 모듈의 모든 imports는 any 타입을 가집니다.
    
+
    속기 모듈로부터 모든 imports는 any 타입을 가집니다.
    
 
    import x, {y} from "hot-new-module";
 x(y);
 
    
-
    Wildcard module declarations
    
-
    SystemJS 및 AMD 같은 일부 모듈 로더들은 JavaScript가 아닌 컨텐츠를 import 할 수 있습니다.
    일반적으로 특별한 로드의 의미론을 나타내는 접두사 또는 접미사를 사용한다.
    이러한 경우를 다루기 위해 Wildcard 모듈 선언을 사용할 수 있습니다.
    
+
    와일드카드 모듈 선언 (Wildcard module declarations)
    
+
    SystemJS나
+AMD와 같은 모듈 로더는 비-JavaScirpt 내용을 import 할 수 있습니다.
+이 둘은 일반적으로 접두사 또는 접미사를 사용하여 특수한 로딩 의미를 표시합니다.
+이러한 경우를 다루기 위해 와일드카드 모듈 선언을 사용할 수 있습니다.
    
 
    declare module "*!text" {
     const content: string;
     export default content;
 }
-// 일부는 그 반대의 방법을 사용합니다.
+// 일부는 다른 방법으로 사용합니다.
 declare module "json!*" {
     const value: any;
     export default value;
 }
 
    
-
    이제 "*!text" 또는 "json!*" 과 일치하는 것을 import 할 수 있습니다.
    
+
    이제 "*!text" 나 "json!*"와 일치하는 것들을 import 할 수 있습니다.
    
 
    import fileContent from "./xyz.txt!text";
 import data from "json!http://example.com/data.json";
 console.log(data, fileContent);
 
    
-
    UMD modules
    
-
    일부 라이브러리는 많은 모듈 로더에서 사용하도록 설계되었거나 모듈 로드가 없습니다 (글로벌 변수).
    이러한 모듈을 UMD 모듈이라고 합니다.
    이러한 라이브러리는 import 또는 글로벌 변수를 통해 접근할 수 있습니다.
    
-
    예를 들어:
    
+
    UMD 모듈 (UMD modules)
    
+
    일부 라이브러리는 많은 모듈 로더에서 사용되거나, 모듈 로딩 (전역 변수) 없이 사용되도록 설계되었습니다.
+이를 UMD 모듈이라고 합니다.
+이러한 라이브러리는 import나 전역 변수를 통해 접근할 수 있습니다.
+예를 들면:
    
 
    math-lib.d.ts
    
 
    export function isPrime(x: number): boolean;
 export as namespace mathLib;
 
    
-
    그러면 라이브러리를 모듈에서 import로 사용할 수 있습니다.
    
+
    라이브러리는 모듈 내에서 import로 사용할 수 있습니다:
    
 
    import { isPrime } from "math-lib";
 isPrime(2);
-mathLib.isPrime(2); // 오류: 모듈 내부에서 전역 정의를 할 수 없습니다.
+mathLib.isPrime(2); // 오류: 모듈 내부에서 전역 정의를 사용할 수 없습니다.
 
    
-
    글로벌 변수로 사용할 수도 있지만 스크립트 내부에서만 사용할 수 있습니다.
    (스크립트는 imports 또는 exports가 없는 파일입니다)
    
+
    전역 변수로도 사용할 수 있지만, 스크립트 내에서만 사용할 수 있습니다.
+(스크립트는 imports나 exports가 없는 파일입니다.)
    
 
    mathLib.isPrime(2);
 
    
-
    모듈 구조화를 위한 가이드 (Guidance for structuring modules)
    
-
    최상위 레벨에 가깝게 내보내기 (Export as close to top-level as possible)
    
-
    모듈의 사용자들은 export 한 것들을 사용할 때 가능한 한 마찰이 적어야 합니다.
    너무 많은 중첩의 레벨을 추가하는 것은 다루기 힘들기 때문에 구조화 방법에 대해 신중히 생각하세요.
    
-
    모듈에서 네임스페이스를 export 하는 것은 중첩 계층을 너무 많이 추가하는 예입니다.
    네임스페이스가 필요할때도 있지만 모듈을 사용할 때는 추가적인 레벨의 간접 참조를 추가합니다.
    이는 사용자에게 재빠르게 고통이 될 수 있으며 일반적으로 불필요합니다.  
    
-
    export 클래스의 정적 메서드에도 비슷한 문제가 있습니다 - 클래스 자체적으로 중첩 계층을 추가합니다.
    표현이나 의도가 명확하고 유용한 방식으로 증가하지 않는 한 간단한 헬퍼 함수를 내보내는 것을 고려하세요.
    
-
    단일 class 또는 function만 export하는 경우 export default를 사용하세요 (If you're only exporting a single class or function, use export default)
    
-
    "최상위 레벨에 가깝게 내보내기"가 모듈 사용자의 마찰을 줄이는 것처럼 default export를 도입하는 것도 마찬가지입니다.
    모듈의 주요 목적이 하나의 특정 export를 저장하는 것이라면 이를 default export로 export 하는 것을 고려해야 합니다.
    이렇게 하면 importing를 사용하며 실제로 import를 더 쉽게 사용할 수 있습니다.
    
-
    예를 들어:
    
+
    모듈 구조화에 대한 지침 (Guidance for structuring modules)
    
+
    가능한 최상위-레벨에 가깝게 export 하기 (Export as close to top-level as possible)
    
+
    모듈의 사용자가 export 모듈을 사용할 때 가능한 마찰이 적어야 합니다.
+중첩 수준을 과도하게 추가하면 다루기 힘들어지는 경향이 있으므로, 어떻게 구조를 구성할지 신중하게 생각해야 합니다.
    
+
    모듈에서 네임스페이스를 export 하는 것은 너무 많은 중첩 레이어를 추가하는 예입니다.
+네임스페이스는 때때로 용도가 있지만, 모듈을 사용할 때 추가적인 레벨의 간접 참조를 추가합니다.
+이것은 사용자에게 금방 고통스러운 지점이 될 수 있고, 일반적으로 불필요합니다.
    
+
    export 한 클래스의 정적 메서드에도 비슷한 문제가 있습니다 - 클래스 자체에 중첩 레이어가 추가됩니다.
+표현이나 의도를 명확하게 유용한 방식으로 높이지 않는 한 간단하게 헬퍼 함수를 export 하는 것을 고려하세요.
    
+
    단일 class나 function을  export 할 경우, export default를 사용하세요 (If you're only exporting a single class or function, use export default)
    
+
    "최상위-레벨에 가까운 export"가 모듈 사용자의 마찰을 줄여주는 것처럼, default export를 도입하는 것도 마찬가지입니다.
+모듈의 주요 목적이 한 개의 특정 export를 저장하는 것이라면, default export로 export 하는 것을 고려하세요.
+이렇게 하면 import 하기와 실제로 import를 사용하기가 더 쉬워집니다.
+예를 들면:
    
 
    MyClass.ts
    
 
    export default class SomeType {
   constructor() { ... }
@@ -1104,20 +1205,20 @@ 
    Consumer.ts
    
 let x = new t();
 console.log(f());
 
    
-
    이는 사용자를 위한 최적의 선택입니다.
    타입의 이름을 원하는 대로 지을 수 있으며(이 경우 t) 객체를 찾기 위해 과도하게 점을 찍을 필요가 없습니다.
    
-
    다수의 객체를 내보내는 경우 모두 최상위 레벨에 배치하세요. (If you're exporting multiple objects, put them all at top-level)
    
+
    이것은 사용자에게 최적입니다. 타입에 원하는 이름(이 경우에는 t)을 지정할 수 있고 객체를 찾기 위해 과도한 점을 찍지 않아도 됩니다.
    
+
    여러 객체를 export 하는 경우, 최상위-레벨에 두세요 (If you're exporting multiple objects, put them all at top-level)
    
 
    MyThings.ts
    
 
    export class SomeType { /* ... */ }
 export function someFunc() { /* ... */ }
 
    
-
    반대로 가져올 때:
    
-
    imported 이름을 명시적으로 나열 (Explicitly list imported names)
    
+
    반대로 import 할 때:
    
+
    import 한 이름을 명시적으로 나열 (Explicitly list imported names)
    
 
    Consumer.ts
    
 
    import { SomeType, someFunc } from "./MyThings";
 let x = new SomeType();
 let y = someFunc();
 
    
-
    다수를 importing 하는 경우 네임스페이스 import 패턴 사용 (Use the namespace import pattern if you're importing a large number of things)
    
+
    많은 것을 import 하는 경우, 네임스페이스 import 패턴을 사용하세요 (Use the namespace import pattern if you're importing a large number of things)
    
 
    MyLargeModule.ts
    
 
    export class Dog { ... }
 export class Cat { ... }
@@ -1128,9 +1229,13 @@ 
    Consumer.ts
    
 
    import * as myLargeModule from "./MyLargeModule.ts";
 let x = new myLargeModule.Dog();
 
    
-
    확장을 위한 다시 내보내기 (Re-export to extend)
    
-
    종종 모듈의 기능을 확장해야 합니다.
    일반적인 JS 패턴은 JQuery 확장이 작동하는 것과 비슷한 extensions을 사용하여 원본 객체를 보강하는 것입니다.
    앞서 언급했듯이 모듈은 전역 네임스페이스 객체처럼 병합되지 않습니다.
    권장되는 해결책은 원본 객체를 변형시키지 않고 새로운 기능을 제공하는 새로운 엔티티를 export하는  것입니다.
    
-
    Calculator.ts 모듈에 정의된 간단한 계산기 구현을 고려해보세요.
    또한 모듈은 입력 문자열 목록을 전달하고 끝에 결과를 작성하여 계산기 기능을 테스트하는 헬퍼 함수를 exports 합니다.
    
+
    상속을 위한 re-export 하기 (Re-export to extend)
    
+
    종종 모듈의 기능을 확장해야 할 필요가 있습니다.
+일반적인 JS 패턴은 JQuery 확장이 작동하는 방식과 유사하게 확장(extensions)으로 기존의 객체를 보강하는 것입니다.
+앞에서 언급했듯이 모듈은 전역 네임스페이스 객체와 같이 병합(merge) 하지 않습니다.
+여기서 추천하는 방법은 기존의 객체를 변형하지 않고 새로운 기능을 제공하는 개체를 export 하는 것입니다.
    
+
    Calculator.ts 모듈에 정의된 간단한 계산기 구현을 생각해보세요.
+이 모듈도 입력 문자열 목록을 전달하고 결과를 작성하여 계산기의 기능을 테스트할 수 있는 헬퍼 함수를 export 합니다.
    
 
    Calculator.ts
    
 
    export class Calculator {
     private current = 0;
@@ -1168,7 +1273,7 @@ 
    Calculator.ts
    
         this.current = 0;
     }
 
-    public handelChar(char: string) {
+    public handleChar(char: string) {
         if (char === "=") {
             this.evaluate();
             return;
@@ -1198,21 +1303,21 @@ 
    Calculator.ts
    
 
 export function test(c: Calculator, input: string) {
     for (let i = 0; i < input.length; i++) {
-        c.handelChar(input[i]);
+        c.handleChar(input[i]);
     }
 
     console.log(`result of '${input}' is '${c.getResult()}'`);
 }
 
    
-
    다음은 test 함수를 사용한 계산기의 간단한 테스트입니다.
    
+
    노출된 test 함수를 사용하는 간단한 계산기 테스트입니다.
    
 
    TestCalculator.ts
    
 
    import { Calculator, test } from "./Calculator";
 
 
 let c = new Calculator();
-test(c, "1+2*33/11="); // 9
+test(c, "1+2*33/11="); // 9 출력
 
    
-
    이제 이것을 확장하여 10이 아닌 다른 수의 입력에 대한 지원을 추가하기 위한 ProgrammerCalculator.ts를 작성해 봅시다.
    
+
    10이 아닌 숫자를 입력받을 수 있도록 이것을 상속하여 ProgrammerCalculator.ts을 만들어보겠습니다.
    
 
    ProgrammerCalculator.ts
    
 
    import { Calculator } from "./Calculator";
 
@@ -1221,46 +1326,56 @@ 
    ProgrammerCalculator.ts
    
 
     constructor(public base: number) {
         super();
-        if (base <= 0 || base > ProgrammerCalculator.digits.length) {
-            throw new Error("base has to be within 0 to 16 inclusive.");
-        }
-    }
-
-    protected processDigit(digit: string, currentValue: number) {
-        if (ProgrammerCalculator.digits.indexOf(digit) >= 0) {
-            return currentValue * this.base + ProgrammerCalculator.digits.indexOf(digit);
-        }
-    }
-}
-
-// 새롭게 확장된 계산기를 계산기로 export 합니다.
-export { ProgrammerCalculator as Calculator };
-
-// 또한 헬퍼 함수를 export 합니다.
-export { test } from "./Calculator";
+        const maxBase = ProgrammerCalculator.digits.length;
+        if (base <= 0 || base > maxBase) {
+            throw new Error(`base has to be within 0 to ${maxBase} inclusive.`);
+        }
+    }
+
+    protected processDigit(digit: string, currentValue: number) {
+        if (ProgrammerCalculator.digits.indexOf(digit) >= 0) {
+            return currentValue * this.base + ProgrammerCalculator.digits.indexOf(digit);
+        }
+    }
+}
+
+// 새로 상속된 calculator를 Calculator로 export 하기
+export { ProgrammerCalculator as Calculator };
+
+// 또한 헬퍼 함수도 export 하기
+export { test } from "./Calculator";
 
    
-
    다음은 우리의 ProgrammerCalculator 클래스에 대한 테스트입니다.
    새로운 모듈 ProgrammerCalculator는 원래 Calculator 모듈과 비슷한 API 형태을 export 하지만 원본 모듈의 어떠한 객체도 보강하지 않습니다.
    
-
    다음은 ProgrammerCalculator 클래스에 대한 테스트입니다:
    
+
    새로운 ProgrammerCalculator 모듈은 Calculator 모듈과 유사한 API 형태를 export 하지만, 원래 모듈의 객체를 보강하지는 않습니다.
+다음은 ProgrammerCalculator 클래스에 대한 테스트입니다:
    
 
    TestProgrammerCalculator.ts
    
 
    import { Calculator, test } from "./ProgrammerCalculator";
 
 let c = new Calculator(2);
-test(c, "001+010="); // 3
+test(c, "001+010="); // 3 출력
 
    
-
    모듈에서 네임 스페이스를 사용하지 마세요 (Do not use namespaces in modules)
    
-
    모듈 기반 조직으로 처음 이동할 때의 트렌드는 추가 네임 스페이스 계층에 exports를 래핑하는 것입니다.
    모듈에는 자체적인 스코프가 있으며 exports 선언만 모듈 외부에서 볼 수 있습니다.
    이를 염두에 두고 네임스페이스는 모듈을 사용할 때 매우 작은 값을 제공합니다.
    
-
    조직 측면에서는 네임스페이스가 논리적으로 관련된 객체와 타입을 전역 스코프로 그룹화할 때 편리합니다.
    예를 들어 C#에서는 System.Collections의 모든 컬렉션 타입을 찾습니다.  
    
-
    타입을 계층적 네임스페이스로 구성하여 이러한 타입의 사용자에게 훌륭한 "발견" 경험을 제공합니다.
    반면 모듈은 필수적으로 파일 시스템에 이미 존재합니다.
    경로와 파일 이름으로 해결해야 하므로 사용할 수있는 논리적 조직 체계가 있습니다.
    목록 모듈이 포함된 /collections/generic/ 폴더를 사용할 수 있습니다.
    
-
    전역 스코프에서 충돌된 이름을 지정하지 않으려면 네임스페이스가 중요합니다.
    예를 들어  My.Application.Customer.AddForm과 My.Application.Order.AddForm 같은 이름이지만 다른 네임스페이스를 가진 두 가지 타입이 있을 수 있습니다.
    그러나 이것은 모듈과 관련된 문제는 아닙니다.
    모듈 내에서 동일한 이름을 가진 두 개의 객체를 갖는 그럴듯한 이유는 없습니다.
    사용자는 모듈을 참조하는 데 사용할 이름을 선택하게 되므로 우연한 이름 충돌은 불가능합니다.
    
+
    모듈에서 네임스페이스를 사용하지 마세요 (Do not use namespaces in modules)
    
+
    모듈 기반 구성을 처음 적용할 때, 일반적으로 추가적인 네임스페이스 계층에서 exports를 래핑 하는 경향이 있습니다.
+모듈에는 자체 스코프가 있으며, export된 선언만 모듈 외부에서 볼 수 있습니다.
+이를 염두에 두고 네임스페이스는 모듈을 다룰 때 거의 값을 변경하지 않습니다.
    
+
    구성 전면에서 네임스페이스는 논리적으로 관련된 개체와 타입을 전역 스코프로 그룹화하는데 편리합니다.
+예를 들어, C#의 경우, System.Collections에서 모든 컬렉션 타입을 찾을 수 있습니다.
+타입을 계층적 네임스페이스로 구성하여 해당 타입의 사용자에게 "발견"할 수 있는 좋은 경험을 제공합니다.
+반면, 모듈은 이미 파일 시스템에 반드시 존재합니다.
+경로와 파일 이름으로 해석하기 위해서, 논리적 구성 체계를 사용할 수 있습니다.
+리스트 모듈이 있는 /collections/generic/ 폴더를 사용할 수 있습니다.
    
+
    네임스페이스는 전역 스코프에서 네이밍 충돌을 피하기 위해 중요합니다.
+예를 들어, My.Application.Customer.AddForm과 My.Application.Order.AddForm -- 두 타입의 이름은 같지만 다른 네임스페이스를 가지고 있습니다.
+그러나 이것은 모듈에서 문제가 되지 않습니다.
+모듈 내에서 두 개의 객체가 같은 이름을 가질만한 이유는 없습니다.
+사용 측면에서 특정 모듈의 사용자는 모듈을 참조하는데 사용할 이름을 선택하므로 우연한 이름 충돌은 불가능합니다.
    
 
    
-
    모듈과 네임스페이스에 대한 자세한 내용은 네임 스페이스와 모듈을 참조하세요.
    
+
    모듈과 네임스페이스에 대한 자세한 내용은 Namespaces and Modules를 참고하세요
    
 
    
 
    위험 신호 (Red Flags)
    
-
    다음은 모두 모듈 구조화를 위한 위험 요소들입니다.
    이 중 하나라도 파일에 적용되는 경우 외부 모듈의 네임스페이스를 지정하려고 하지 않는지 다시 확인하세요.
    
+
    다음은 모두 모듈 구조화에 대한 위험 신호입니다. 다음 중 하나라도 파일에 적용되는 경우 외부 모듈의 네임스페이스를 만들려고 하지 않았는지 다시 확인하세요:
    
 
      
-
    • 오직 최상위 레벨 선언만 export namespace Foo { ... }인 파일 (Foo를 제거하고 모든 것을 '위로' 이동시키세요)
      • 
-
    • 단일 export class 또는 export function가 있는 파일 (export default 사용을 고려하세요)
      • 
-
    • 최상위 파일 위치에 동일한 export namespace Foo {를 가진 다수의 파일 (이것들이 Foo 하나로 결합될 것이라고 생각하지 마세요!)
      • 
+
    • 오직 최상위-레벨 선언만 export namespace Foo { ... }인 파일 (Foo를 제거하고 모든 것을 '상위' 레벨로 이동하세요)
      • 
+
    • 최상위-레벨 위치에 동일한 export namespace Foo {를 가진 여러 파일 (하나의 Foo로 결합될 거라 생각하지 마세요!)
      • 
 
    
 
                                 
@@ -1305,7 +1420,7 @@ 
    No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"모듈","level":"3.13","depth":1,"next":{"title":"네임스페이스","level":"3.14","depth":1,"path":"pages/Namespaces.md","ref":"pages/Namespaces.md","articles":[]},"previous":{"title":"이터레이터와 제네레이터","level":"3.12","depth":1,"path":"pages/Iterators and Generators.md","ref":"pages/Iterators and Generators.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Modules.md","mtime":"2019-06-14T05:32:52.246Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"모듈","level":"3.13","depth":1,"next":{"title":"네임스페이스","level":"3.14","depth":1,"path":"pages/Namespaces.md","ref":"pages/Namespaces.md","articles":[]},"previous":{"title":"이터레이터와 제네레이터","level":"3.12","depth":1,"path":"pages/Iterators and Generators.md","ref":"pages/Iterators and Generators.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Modules.md","mtime":"2020-04-22T15:29:36.176Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Namespaces and Modules.html b/pages/Namespaces and Modules.html
index a005eaae..6bd97651 100644
--- a/pages/Namespaces and Modules.html	
+++ b/pages/Namespaces and Modules.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
    • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
  • 
+        
  • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
    • 
+    
+        
  • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
  • 릴리즈 노트
    • 
+        
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
    • 
+    
+
+    
 
     
  • 
 
@@ -711,26 +757,34 @@ 
    
     
                                 
    
                                 
-                                
    
-
    용어에 대한 참고 사항:
-TypeScript 1.5에 명칭이 변경되었습니다.
    "내부 모듈"은 이제 "네임스페이스"입니다.
    "외부 모듈"은 ECMAScript 2015의 용어에 맞게 간단히 "모듈"입니다 (즉 모듈 X { 는 현재 선호되는 네임스페이스 X { 와 동일합니다).
    
-
    
-
    소개
    
-
    이 게시물은 TypeScript의 네임스페이스와 모듈을 사용하여 구성하는 다양한 방법을 설명합니다.
    또한 네임스페이스와 모듈을 사용하는 방법에 대한 몇 가지 고급 주제를 살펴보고 TypeScript에서 사용할 때 일반적인 몇 가지 함정을 다룰 예정입니다.
    
-
    모듈에 대한 자세한 내용은 모듈의 문서를 참조하세요.
    네임스페이스에 대한 자세한 내용은 네임스페이스의 문서를 참조하세요.
    
-
    네임스페이스 사용하기 (Using Namespaces)
    
-
    네임스페이스는 전역 네임스페이스에서 JavaScript 객체로 불립니다.
    네임스페이스를 매우 사용하기 간단한 구조로 만듭니다.
    여러 파일에 걸쳐있을 수 있으며 --outFile을 사용하여 연결될 수 있습니다.
    네임스페이스는 HTML 페이지에 <script> 태그로 포 된 모든 의존성을 가진 웹 애플리케이션에서 코드를 구조화하는 좋은 방법이 될 수 있습니다.
    
-
    모든 전역 네임스페이스 오염과 마찬가지로, 특히 대규모 애플리케이션에서는 구성 요소 의존성을 식별하기 어려울 수 있습니다.
    
+                                
    소개 (Introduction)
    
+
    이 글에서는 TypeScript에서 모듈과 네임스페이스를 사용하여 코드를 구성하는 다양한 방법을 간략하게 설명합니다.
+또한 네임스페이스와 모듈에 관한 몇 가지 고급 주제와 TypeScript에서 네임스페이스와 모듈을 사용할 때 흔히 마주치는 위험성을 살펴볼 것입니다.
    
+
    ES 모듈에 대한 자세한 내용은 모듈 문서를 참고하세요.
+TypeScript 네임스페이스에 대한 자세한 내용은 네임스페이스 문서를 참고하세요.
    
+
    참고: 매우 오래된 버전의 TypeScript 네임스페이스는 이전의 JavaScript 모듈 시스템인 '내부 모듈'이라고 불렸습니다.
    
 
    모듈 사용하기 (Using Modules)
    
-
    네임 스페이스와 마찬가지로 모듈에는 코드와 선언을 모두 포함시킵니다.
    가장 큰 차이점은 모듈이 의존성을 선언한다는 것입니다.
    
-
    모듈은 또한 모듈 로더에 대한 의존성을 가지고 있습니다 (예: CommonJs/Require.js)
    작은 JS 애플리케이션의 경우는 최적이 아닐 수도 있지만 대규모 애플리케이션의 경우 장기적인 모듈성 및 유지 관리에 이점이 있습니다.
    모듈은 더 나은 코드 재사용, 강력한 격리 및 번들링을 위한 향상된 도구 지원을 제공합니다.
    
-
    또한 Node.js 애플리케이션의 경우 모듈이 기본이며 코드를 구조화하기 위한 권장 방법임을 유의해야 합니다.
    
-
    ECMAScript 2015 부터는 모듈은 언어의 기본 요소이며 모든 호환 엔진 구현에서 지원해야 합니다.
    따라서 새로운 프로젝트의 경우 모듈이 코드 구성 메커니즘의 권장 사항이 됩니다.
    
-
    네임스페이스와 모듈의 위험 (Pitfalls of Namespaces and Modules)
    
-
    이 섹션에서는 네임스페이스와 모듈을 사용할 때 흔히 발생하는 다양한 위험에 대해 설명하고 이를 피하는 방법에 대해 알아보겠습니다.
    
-
    /// <reference>-ing a module
    
-
    일반적인 실수는 import 문을 사용하는 대신 모듈 파일을 참조하기 위해 /// <reference ... /> 문을 사용하는 것이다.
    차이점을 이해하기 위해서는, 우선 컴파일러가 import(예:'...'에서 '...',import x from "...";에서 import x = require("..."); 경로를 기반으로 모듈에 대한 타입 정보를 찾는 방법을 먼저 이해할 필요가 있습니다.
    
-
    컴파일러는 적절한 경로로 .ts, .tsx 그리고.d.ts를 찾으려 할 겁니다.
    특정 파일을 찾을 수 없으면 컴파일러는 ambient 모듈 선언을 찾습니다.
    이 파일들을 .d.ts 파일에 선언해야 한다는 것을 기억해야 합니다.
    
+
    모듈에는 코드와 선언 둘 다 포함될 수 있습니다.
    
+
    모듈은 또한 모듈 로더(예: CommonJs/Require.js)에 대한 의존성이나 ES 모듈이 지원하는 런타임을 가지고 있습니다.
+모듈은 더 나은 코드 재사용성을 위해, 강력한 고립성과 번들링을 위한 향상된 도구를 제공합니다.
    
+
    또한 Node.js 애플리케이션의 경우 모듈이 기본적인 방법이며, 코드를 구조화하는 데 있어 권장하는 접근법이라는 점을 유의해야 합니다.
    
+
    ECMAScript 2015부터, 모듈은 언어에서 기본적으로 내재한 부분이며, 모든 호환 엔진 구현은 모듈을 지원해야 합니다.
+따라서, 새로운 프로젝트의 경우 코드를 구성하는 방법으로 모듈을 권장합니다.
    
+
    네임스페이스 사용하기 (Using Namespaces)
    
+
    네임스페이스는 코드를 구성하는 TypeScript만의 고유한 방법입니다.
+네임스페이스는 간단히 전역 네임스페이스에서 JavaScript 객체로 이름 붙여집니다.
+이러한 점 덕분에 네임스페이스를 아주 단순한 구조로 사용할 수 있습니다.
+모듈과 달리, 여러 개의 파일을 포괄할 수 있으며, --outFile을 사용해 연결할 수 있습니다.
+네임스페이스는 웹 애플리케이션에서 코드를 구조화하기에 좋은 방법이며, 모든 의존성은 HTML 페이지의 <script> 태그로 포함합니다.
    
+
    특히 대규모 애플리케이션의 경우, 이 방법은 모든 전역 네임스페이스가 오염되는 경우와 마찬가지로 컴포넌트의 의존성을 식별하기 힘들게 만들 수 있습니다.
    
+
    네임스페이스와 모듈의 위험성 (Pitfalls of Namespaces and Modules)
    
+
    여기서는 네임스페이스와 모듈을 사용할 때 자주 발생하는 다양한 위험성과 그 해결책을 알아보겠습니다.
    
+
    /// <reference>를 사용한 모듈
    
+
    일반적인 실수는 모듈 파일을 참조하기 위해 import문 대신 /// <reference ... /> 구문을 사용하는 것입니다.
+이 둘의 차이를 이해하기 위해, 우선 import 경로에 위치한 모듈에 대한 타입 정보를 컴파일러가 어떻게 찾아내는지를 이해해야 합니다. (예를 들어, import x from "...";, import x = require("..."); 등 안의 ...)
    
+
    컴파일러는 .ts, .tsx를 찾은 다음 적절한 경로에 위치한 .d.ts를 찾습니다.
+만약 특정 파일을 찾지 못한다면, 컴파일러는 앰비언트 모듈(ambient module) 선언을 탐색할 것입니다.
+.d.ts 파일안에 이것들을 선언해야 한다는 점을 기억하세요.
    
 
      
 
    • myModules.d.ts
      
 
      // 모듈이 아닌 .d.ts 파일 또는 .ts 파일:
@@ -745,9 +799,10 @@ 
      /// <reference>-ing a module<
 
      
 
      • 
 
    
-
    여기서 참조 태그는 ambient 모듈에 대한 선언을 포함하는 선언 파일을 찾을 수 있게 해줍니다.
    이것은 다수의 TypeScript 샘플에서 사용되는 node.d.ts 파일이 사용되는 방법입니다.
    
+
    위의 reference 태그는 앰비언트 모듈(ambient module) 선언이 포함된 선언 파일의 위치를 지정하는 데 필요합니다.
+이 방법은 여러 TypeScript 샘플에서 사용하는 node.d.ts파일을 사용하는 방법입니다.
    
 
    불필요한 네임스페이스 (Needless Namespacing)
    
-
    프로그램을 네임스페이스에서 모듈로 변환하는 경우에는 다음과 파일로 같은 쉽게 끝날 수 있습니다:
    
+
    네임스페이스를 사용하던 프로그램을 모듈로 변경하면, 파일은 다음과 같은 모습이 되기 쉽습니다:
    
 
      
 
    • shapes.ts
      
 
      export namespace Shapes {
@@ -757,7 +812,8 @@ 
      import * as shapes from "./shapes";
@@ -765,9 +821,11 @@ 
      export class Triangle { /* ... */ }
@@ -780,8 +838,10 @@ 
      모듈의 관계 (Trade-offs of Modules)
      
-
      JS 파일과 모듈 사이에 일대일 대응이 있는 것과 마찬가지로 TypeScript는 모듈 소스 파일과 방출된 JS 파일 간에 일대일 대응을 합니다.
      이에 따른 한가지 효과는 대상 모듈 시스템에 따라 여러 모듈 소스 파일을 연결할 수 없다는 것입니다.
      예를 들어 commonjs 또는 umd를 대상으로 하는 동안 outFile 옵션을 사용할 수 없지만 TypeScript 1.8 이상에서는 amd 또는 system을 대상으로 지정할 때 outFile을 사용할 수 있습니다.
      
+
      모듈의 트레이드-오프 (Trade-offs of Modules)
      
+
      JS 파일과 모듈이 일대일 대응인 것처럼, TypeScript는 모듈 소스 파일과 이 파일에서 생성된 JS 파일도 일대일 대응입니다.
+이러한 특성 때문에 어떤 모듈 시스템을 사용하느냐에 따라서 여러 모듈 소스 파일을 합치는 작업이 불가능할 수 있습니다.
+예를 들어, commonjs 또는 umd를 대상으로 하는 동안에는 outFile 옵션을 사용할 수 없지만,   TypeScript 1.8 이후부터, amd 또는 system를 대상으로 하는 경우에는 outFile 옵션을 사용할 수 있게 되었습니다.
      
 
                                 
                                 
    
@@ -825,7 +885,7 @@ 
    No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"네임스페이스와 모듈","level":"3.15","depth":1,"next":{"title":"모듈 해석","level":"3.16","depth":1,"path":"pages/Module Resolution.md","ref":"pages/Module Resolution.md","articles":[]},"previous":{"title":"네임스페이스","level":"3.14","depth":1,"path":"pages/Namespaces.md","ref":"pages/Namespaces.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Namespaces and Modules.md","mtime":"2019-06-14T05:32:52.246Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"네임스페이스와 모듈","level":"3.15","depth":1,"next":{"title":"모듈 해석","level":"3.16","depth":1,"path":"pages/Module Resolution.md","ref":"pages/Module Resolution.md","articles":[]},"previous":{"title":"네임스페이스","level":"3.14","depth":1,"path":"pages/Namespaces.md","ref":"pages/Namespaces.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Namespaces and Modules.md","mtime":"2020-04-22T15:29:36.177Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Namespaces.html b/pages/Namespaces.html
index 5fc8c45f..d031dbde 100644
--- a/pages/Namespaces.html
+++ b/pages/Namespaces.html
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
    • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
  • 
+        
  • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
    • 
+    
+        
  • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
  • 릴리즈 노트
    • 
+        
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
    • 
+    
+
+    
 
     
  • 
 
@@ -711,15 +757,33 @@ 
    
     
                                 
    
                                 
-                                
    
-
    용어에 대한 참고 사항:
-TypeScript 1.5에 명칭이 변경되었습니다.
    "내부 모듈"은 이제 "네임스페이스"입니다.
    "외부 모듈"은 ECMAScript 2015의 용어에 맞게 간단히 "모듈"입니다 (즉 모듈 X { 는 현재 선호되는 네임스페이스 X { 와 동일합니다).
    
-
    
-
    소개
    
-
    이 게시물은 TypeScript의 네임스페이스(이전의 "내부 모듈")를 사용하여 코드를 구성하는 다양한 방법을 간략하게 설명합니다.
    용어에 대해 언급할 때 "내부(internal) 모듈"은 이제 "네임스페이스"로 언급됩니다.
    또 내부 모듈을 선언할 때 module 키워드가 사용된 곳이라면 어디에서나 namespace 키워드를 대신 사용할 수 있습니다.
    비슷한 이름의 용어로 오버로드함으로써 새로운 사용자에게 주는 혼동을 방지합니다.
    
-
    첫 걸음 (First steps)
    
-
    먼저 이 페이지의 예제로 사용할 프로그램에서부터 시작해보겠습니다.
    웹 페이지의 양식에 대한 사용자 입력을 확인하거나 외부에서 제공하는 데이터 파일의 형식을 확인하기 위해 작성할 수 있는 간단한 문자열 유효성 검사기를 작성했습니다.
    
-
    단일 파일의 유효성 검사기 (Validators in a single file)
    
+                                
    목차 (Table of Contents)
    
+
    소개 (Introduction)  
    
+
    첫 번째 단계 (First steps)  
    
+
+
    네임스페이스 적용하기 (Namespacing)  
    
+
+
    파일 간 분할 (Splitting Across Files)  
    
+
+
    별칭 (Aliases)  
    
+
    다른 JavaScript 라이브러리로 작업하기 (Working with Other JavaScript Libraries)  
    
+
+
    소개 (Introduction)
    
+
    ↥ 위로
    
+
    이 게시물에서는 TypeScript에서 네임스페이스를 사용하여 코드를 구성하는 다양한 방법을 간략하게 설명합니다.
    
+
    첫 번째 단계 (First steps)
    
+
    ↥ 위로
    
+
    이 페이지 전체에서 예제로 사용할 프로그램을 시작하겠습니다.
+웹 페이지의 양식에 대한 사용자 입력을 확인하거나 외부로부터 받은 데이터 파일의 형식을 확인하기 위해 간단한 문자열 검사기 세트를 작성했습니다.
    
+
    단일 파일 검사기 (Validators in a single file)
    
 
    interface StringValidator {
     isAcceptable(s: string): boolean;
 }
@@ -739,15 +803,15 @@ 
    // 시험용 샘플
+// 시도해 볼 샘플
 let strings = ["Hello", "98052", "101"];
 
-// 사용할 Validators
+// 사용할 검사기
 let validators: { [s: string]: StringValidator; } = {};
 validators["ZIP code"] = new ZipCodeValidator();
 validators["Letters only"] = new LettersOnlyValidator();
 
-// 각 문자열이 Validator를 통과했는지 여부를 보여 줍니다.
+// 각 문자열이 각 검사기를 통과했는지 표시
 for (let s of strings) {
     for (let name in validators) {
         let isMatch = validators[name].isAcceptable(s);
@@ -755,10 +819,12 @@ 
    Namespacing
    
-
    Validator를 더 추가함에 따라 타입을 추적하고 다른 객체와의 이름 충돌에 대해 걱정하지 않을 수 있는 일종의 조직 체계를 원할 것입니다.
    전역 네임스페이스에 다른 이름을 많이 추가하는 대신 객체를 네임스페이스로 마무리합시다.
    
-
    이 예제에서는 모든 validator 관련 엔티티를 Validation라는 네임스페이스로 이동합니다.
    여기서 인터페이스와 클래스를 네임스페이스 외부에서 볼 수 있기를 원하기 때문에 export를 머리말에 붙입니다.
    반대로 변수 lettersRegexp와 numberRegexp는 구현 세부 사항이므로 노출되지 않은 상태로 남아있어 네임스페이스 외부의 코드에는 보이지 않습니다.
    파일의 아래쪽에 있는 테스트 코드에서 (예: Validation.LettersOnlyValidator)와 같이 네임스페이스 외부에서 사용할 경우 타입의 이름을 확인해야 합니다.
    
-
    Namespaced Validators
    
+
    네임스페이스 적용하기 (Namespacing)
    
+
    더 많은 검사기를 추가하게 되면, 타입을 추적하고 다른 객체와 이름 충돌을 방지하기 위해 일종의 구조 체계가 필요합니다.
+전역 네임스페이스에 다른 이름을 많이 넣는 대신, 객체들을 하나의 네임스페이스로 감싸겠습니다.
    
+
    이 예에서는 모든 검사기 관련 개체를 Validation이라는 하나의 네임스페이스로 옮기겠습니다.
    여기서 인터페이스 및 클래스가 네임스페이스 외부에서도 접근 가능하도록 선언부에 export를 붙입니다.
    반면, 변수 letterRegexp와 numberRegexp는 구현 세부 사항이므로 외부로 내보내지 않아 네임스페이스 외부 코드에서 접근할 수 없습니다.
+파일 하단의 테스트 코드에서, 네임스페이스 외부에서 사용될 때 타입의 이름을 검증해야 합니다 (예: Validation.LetterOnlyValidator).
    
+
    네임스페이스화된 검사기 (Namespaced Validators)
    
 
    namespace Validation {
     export interface StringValidator {
         isAcceptable(s: string): boolean;
@@ -780,33 +846,38 @@ 
    Namespaced Validators
    
     }
 }
 
-// 시험용 샘플
+// 시도해 볼 샘플
 let strings = ["Hello", "98052", "101"];
 
-// 사용할 Validators
+// 사용할 검사기
 let validators: { [s: string]: Validation.StringValidator; } = {};
 validators["ZIP code"] = new Validation.ZipCodeValidator();
 validators["Letters only"] = new Validation.LettersOnlyValidator();
 
-// 각 문자열이 Validator를 통과했는지 여부를 보여 줍니다.
+// 각 문자열이 각 검사기를 통과했는지 표시
 for (let s of strings) {
     for (let name in validators) {
         console.log(`"${ s }" - ${ validators[name].isAcceptable(s) ? "matches" : "does not match" } ${ name }`);
     }
 }
 
    
-
    파일 분할 (Splitting Across Files)
    
-
    애플리케이션이 증가함에 따라 코드를 여러 파일로 나누어 유지 보수하기 쉽게 만들려고 합니다.
    
-
    Multi-file namespaces
    
-
    여기서 Validation 네임스페이스를 많은 파일들로 나눌 것입니다.
    파일은 별개이지만 각각 동일한 네임스페이스에 기여할 수 있으며 모든 파일이 한곳에서 정의된 것처럼 사용할 수 있습니다.
    파일 간 의존성이 있기 때문에 컴파일러에게 파일들 간의 관계를 알려주는 참조 태그를 추가합니다.
    테스트 코드는 변경되지 않습니다.
    
+
    파일 간 분할 (Splitting Across Files)
    
+
    ↥ 위로
    
+
    애플리케이션 규모가 커지면, 코드를 여러 파일로 분할해야 유지 보수가 용이합니다.  
    
+
    다중 파일 네임스페이스 (Multi-file namespaces)
    
+
    ↥ 위로
    
+
    여기서 Validation 네임스페이스를 여러 파일로 분할합니다.
+파일이 분리되어 있어도 같은 네임스페이스에 기여할 수 있고 마치 한 곳에서 정의된 것처럼 사용할 수 있습니다.
+파일 간 의존성이 존재하므로, 참조 태그를 추가하여 컴파일러에게 파일 간의 관계를 알립니다.
+그 외에 테스트 코드는 변경되지 않았습니다.
    
 
    Validation.ts
    
-
    namespace Validation {
-    export interface StringValidator {
+
    namespace Validation{
+    export interface StringValidator{
         isAcceptable(s: string): boolean;
     }
 }
 
    
-
    LettersOnlyValidator.ts
    
+
    LettersOnlyValidators.ts
    
 
    /// <reference path="Validation.ts" />
 namespace Validation {
     const lettersRegexp = /^[A-Za-z]+$/;
@@ -817,7 +888,7 @@ 
    LettersOnlyValidator.ts
    
     }
 }
 
    
-
    ZipCodeValidator.ts
    
+
    ZipCodeValidators.ts
    
 
    /// <reference path="Validation.ts" />
 namespace Validation {
     const numberRegexp = /^[0-9]+$/;
@@ -833,38 +904,42 @@ 
    Test.ts
    
 /// <reference path="LettersOnlyValidator.ts" />
 /// <reference path="ZipCodeValidator.ts" />
 
-// 시험용 샘플
+// Some samples to try
 let strings = ["Hello", "98052", "101"];
 
-// 사용할 Validators
+// Validators to use
 let validators: { [s: string]: Validation.StringValidator; } = {};
 validators["ZIP code"] = new Validation.ZipCodeValidator();
 validators["Letters only"] = new Validation.LettersOnlyValidator();
 
-// 각 문자열이 Validator를 통과했는지 여부를 보여 줍니다.
+// Show whether each string passed each validator
 for (let s of strings) {
     for (let name in validators) {
         console.log(`"${ s }" - ${ validators[name].isAcceptable(s) ? "matches" : "does not match" } ${ name }`);
     }
 }
 
    
-
    여러 파일이 포함되면 컴파일된 모든 코드를 로드해야 합니다.
    이 작업에는 두 가지 방법이 있습니다.
    
-
    먼저 --outFile을 사용하여 모든 입력 파일을 단일 JavaScript 출력 파일로 컴파일 할 수 있습니다:
    
-
    tsc --outFile sample.js Test.ts
+
    파일이 여러 개 있으면 컴파일된 코드가 모두 로드되는지 확인해야 합니다.
+이를 수행하는 두 가지 방법이 있습니다.
    
+
    먼저, 모든 입력 파일을 하나의 JavaScript 출력 파일로 컴파일하기 위해 --outFile 플래그를 사용하여 연결 출력(concatenated output)을 사용할 수 있습니다:
    
+
    tsc --outFile sample.js Test.ts
 
    
-
    컴파일러는 파일에 있는 참조 태그를 기반으로 출력 파일을 자동으로 정렬합니다.
    각 파일을 개별적으로 지정할 수도 있습니다:
    
-
    tsc --outFile sample.js Validation.ts LettersOnlyValidator.ts ZipCodeValidator.ts Test.ts
+
    컴파일러는 파일에 있는 참조 태그를 기반으로 출력 파일을 자동으로 정렬합니다. 각 파일을 개별적으로 지정할 수도 있습니다:
    
+
    tsc --outFile sample.js Validation.ts LettersOnlyValidator.ts ZipCodeValidator.ts Test.ts
 
    
-
    또는 파일별 컴파일(기본값)을 사용하여 각 입력 파일에 대한 JavaScript 파일을 하나씩 방출할 수 있습니다.
    만약 여러 개의 JS 파일이 생성되면 웹 페이지에 있는 <script>태그를 사용하여 방출된 각 파일을 적절한 순서대로 로드해야 합니다.
    
-
    예를 들어:
    
-
    MyTestPage.html (excerpt)
    
+
    또는 파일별 컴파일 (기본값)을 사용하여 각 입력 파일을 하나의 JavaScript 파일로 생성할 수 있습니다.
+여러 JS 파일이 생성되는 경우, 웹 페이지에서 생성된 개별 파일을 적절한 순서로 로드하기 위해 <script> 태그를 사용해야 합니다. 예를 들어:
    
+
    MyTestPage.html (인용)
    
 
        <script src="Validation.js" type="text/javascript" />
     <script src="LettersOnlyValidator.js" type="text/javascript" />
     <script src="ZipCodeValidator.js" type="text/javascript" />
     <script src="Test.js" type="text/javascript" />
 
    
 
    별칭 (Aliases)
    
-
    네임스페이스 작업을 단순화할 수 있는 또 다른 방법은 import x = require("name")를 사용하여 일반적으로 사용되는 객체의 더 짧은 이름을 생성하는 것입니다.
    이러한 종류의 imports(별칭으로 불림)를 모듈 imports에서 생성된 객체를 포함한 모든 종류의 식별자에 사용할 수 있습니다.
    
+
    ↥ 위로
    
+
    네임스페이스 작업을 단순화할 수 있는 또 다른 방법은 일반적으로 사용되는 객체의 이름을 더 짧게 만들기 위해 import q = x.y.z를 사용하는 것입니다.
+모듈을 로드하는 데 사용되는 import x = require ("name") 구문과 혼동하지 않기 위해, 이 구문은 단순히 특정 심벌에 별칭을 생성합니다.
+이러한 종류의 가져오기(일반적으로 별칭이라고 함)는 모듈 가져오기에서 생성된 객체를 포함하여 모든 종류의 식별자에 대해 사용할 수 있습니다.
    
 
    namespace Shapes {
     export namespace Polygons {
         export class Triangle { }
@@ -873,16 +948,26 @@ 
    별칭 (Aliases)
    
 }
 
 import polygons = Shapes.Polygons;
-let sq = new polygons.Square(); // 'new Shapes.Polygons.Square()'와 동일합니다
+let sq = new polygons.Square(); // 'new Shapes.Polygons.Square()'와 동일
 
    
-
    require 키워드는 사용하지 않습니다. 대신 가져오는 심볼에 걸맞은 이름을 직접 할당합니다.
    이것은 var 사용과 비슷하지만 가져온 심볼의 타입과 네임스페이스 의미에 대해서도 작용합니다.
    중요한 점은, 값의 경우 import는 원래 심볼과 별개의 참조이므로 앨리어싱된 var에 대한 변경 사항은 원래 변수에 반영되지 않습니다.
    
+
    require 키워드를 사용하지 않는다는 것을 명심하세요; 대신 가져오는 심벌은 정해진 이름으로 직접 할당합니다.
+var를 사용하는 것과 비슷하지만, 가져온 심벌의 타입 및 네임스페이스 의미에 대해서도 동작합니다.
+특히, 값의 경우 import는 원래 심벌와 별개의 참조이므로 별칭 var에 대한 변경 내용은 원래 변수에 반영되지 않습니다.
    
 
    다른 JavaScript 라이브러리로 작업하기 (Working with Other JavaScript Libraries)
    
-
    TypeScript에서 작성되지 않은 라이브러리의 형태을 설명하려면 라이브러리에서 표시하는 API를 선언해야 합니다.
    대부분의 JavaScript 라이브러리는 몇 개의 최상위 레벨의 객체만 노출하므로 네임스페이스는 객체를 표현할 수있는 좋은 방법입니다.
    
-
    구현을 "ambient"으로 정의하지 않는 선언을 호출합니다.
    일반적으로 이들은 .d.ts 파일에 정의되어 있습니다.
    C/C++에 익숙하다면 .d.ts 파일로 생각할 수 있습니다.
    몇 가지 예를 살펴보겠습니다.
    
-
    Ambient Namespaces
    
-
    인기 있는 라이브러리 D3는 d3이라는 전역 객체에서 기능을 정의합니다.
    이 라이브러리는 <script> 태그 (모듈 로더 대신)를 통해 로드되기 때문에 선언에 네임스페이스를 사용하여 그 형태을 정의합니다.
    TypeScript 컴파일러가 이 형태을 보려면 ambient 네임스페이스 선언을 사용합니다.
+
    ↥ 위로
    
+
    TypeScript로 작성되지 않은 라이브러리의 형태를 설명하려면, 라이브러리가 외부에 제공하는 API를 선언해야 합니다.
+대부분의 JavaScript 라이브러리는 소수의 최상위 객체만 노출하므로 네임스페이스를 사용하는 것이 좋습니다.
    
+
    구현을 정의하지 않은 선언을 "ambient"라고 부릅니다.
+일반적으로 이것은 .d.ts 파일에 정의되어 있습니다.
+C/C++에 익숙하다면 이를 .h 파일로 생각할 수 있습니다.
+몇 가지 예를 살펴보겠습니다.
    
+
    Ambient 네임스페이스 (Ambient Namespaces)
    
+
    ↥ 위로
    
+
    널리 사용되는 D3 라이브러리는 d3이라는 전역 객체에서 기능을 정의합니다.
+이 라이브러리는 <script> 태그를 통해 로드되므로(모듈 로더 대신) 형태를 정의하기 위해 선언할 때 네임스페이스를 사용합니다.
+TypeScript 컴파일러는 이 형태를 보기 위해, ambient 네임스페이스 선언을 사용합니다.
 예를 들어 다음과 같이 작성할 수 있습니다:
    
-
    D3.d.ts (simplified excerpt)
    
+
    D3.d.ts (간단한 인용)
    
 
    declare namespace D3 {
     export interface Selectors {
         select: {
@@ -946,7 +1031,7 @@ 
    No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"네임스페이스","level":"3.14","depth":1,"next":{"title":"네임스페이스와 모듈","level":"3.15","depth":1,"path":"pages/Namespaces and Modules.md","ref":"pages/Namespaces and Modules.md","articles":[]},"previous":{"title":"모듈","level":"3.13","depth":1,"path":"pages/Modules.md","ref":"pages/Modules.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Namespaces.md","mtime":"2019-06-14T05:32:52.247Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"네임스페이스","level":"3.14","depth":1,"next":{"title":"네임스페이스와 모듈","level":"3.15","depth":1,"path":"pages/Namespaces and Modules.md","ref":"pages/Namespaces and Modules.md","articles":[]},"previous":{"title":"모듈","level":"3.13","depth":1,"path":"pages/Modules.md","ref":"pages/Modules.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Namespaces.md","mtime":"2020-04-22T15:29:36.177Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Nightly Builds.html b/pages/Nightly Builds.html
index 6108bed1..ef115faa 100644
--- a/pages/Nightly Builds.html	
+++ b/pages/Nightly Builds.html	
@@ -73,6 +73,8 @@
     
 
     
+    
+    
     
     
     
@@ -479,6 +481,19 @@
             
 
             
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
    • 
     
 
@@ -625,7 +640,20 @@
             
         
     
-        
  • 
+        
  • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
    • 
+    
+        
  • 
             
                 
             
@@ -638,7 +666,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -651,7 +679,7 @@
             
         
    • 
     
-        
  • 
+        
  • 
             
                 
             
@@ -666,6 +694,26 @@
     
 
     
+        
+        
  • 릴리즈 노트
    • 
+        
+        
+    
+        
  • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
    • 
+    
+
+    
 
     
  • 
 
@@ -788,11 +836,15 @@ 
    No results matching "
+                
                     
                 
                 
                 
+                
+                    
+                
+                
             
         
     
@@ -800,7 +852,7 @@ 
    No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Nightly 빌드","level":"5.5","depth":1,"previous":{"title":"빌드 도구와 통합","level":"5.4","depth":1,"path":"pages/Integrating with Build Tools.md","ref":"pages/Integrating with Build Tools.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Nightly Builds.md","mtime":"2019-06-14T05:32:52.247Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Nightly 빌드","level":"5.6","depth":1,"next":{"title":"TypeScript 3.8","level":"6.1","depth":1,"path":"pages/release notes/TypeScript 3.8.md","ref":"pages/release notes/TypeScript 3.8.md","articles":[]},"previous":{"title":"빌드 도구와 통합","level":"5.5","depth":1,"path":"pages/Integrating with Build Tools.md","ref":"pages/Integrating with Build Tools.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Nightly Builds.md","mtime":"2020-04-22T13:02:03.082Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Project References.html b/pages/Project References.html
new file mode 100644
index 00000000..cbf93816
--- /dev/null
+++ b/pages/Project References.html	
@@ -0,0 +1,993 @@
+
+
+
+    
+        
+        
+        프로젝트 레퍼런스 · GitBook
+        
+        
+				
+				
+        
+        
+        
+        
+        
+    
+    
+    
+
+    
+            
+                
+                
+                
+            
+                
+                
+                
+            
+                
+                
+                
+            
+                
+                
+                
+            
+                
+                
+                
+            
+        
+
+    
+
+    
+        
+    
+        
+    
+        
+    
+        
+    
+        
+    
+        
+    
+
+    
+    
+    
+
+        
+    
+    
+    
+    
+    
+    
+    
+    
+
+    
+    
+    
+    
+    
+    
+
+    
+    
+        
+
    
+    
    
+        
+            
+
+
+            
+                
+            
+        
+    
    
+
+    
    
+        
+            
    
+                
+                    
+
+
+
+
+
+
+                    
    
+                        
    
+                            
+
    
+    
    
+    
+                                
    
+                                
+                                
    Project references are a new feature in TypeScript 3.0 that allow you to structure your TypeScript programs into smaller pieces.
    
+
    By doing this, you can greatly improve build times, enforce logical separation between components, and organize your code in new and better ways.
    
+
    We're also introducing a new mode for tsc, the --build flag, that works hand in hand with project references to enable faster TypeScript builds.
    
+
    An Example Project
    
+
    Let's look at a fairly normal program and see how project references can help us better organize it.
+Imagine you have a project with two modules, converter and units, and a corresponding test file for each:
    
+
    /src/converter.ts
+/src/units.ts
+/test/converter-tests.ts
+/test/units-tests.ts
+/tsconfig.json
+
    
+
    The test files import the implementation files and do some testing:
    
+
    // converter-tests.ts
+import * as converter from "../converter";
+
+assert.areEqual(converter.celsiusToFahrenheit(0), 32);
+
    
+
    Previously, this structure was rather awkward to work with if you used a single tsconfig file:
    
+
      
+
    • It was possible for the implementation files to import the test files
      • 
+
    • It wasn't possible to build test and src at the same time without having src appear in the output folder name, which you probably don't want
      • 
+
    • Changing just the internals in the implementation files required typechecking the tests again, even though this wouldn't ever cause new errors
      • 
+
    • Changing just the tests required typechecking the implementation again, even if nothing changed
      • 
+
    
+
    You could use multiple tsconfig files to solve some of those problems, but new ones would appear:
    
+
      
+
    • There's no built-in up-to-date checking, so you end up always running tsc twice
      • 
+
    • Invoking tsc twice incurs more startup time overhead
      • 
+
    • tsc -w can't run on multiple config files at once
      • 
+
    
+
    Project references can solve all of these problems and more.
    
+
    What is a Project Reference?
    
+
    tsconfig.json files have a new top-level property, references. It's an array of objects that specifies projects to reference:
    
+
    {
+    "compilerOptions": {
+        // The usual
+    },
+    "references": [
+        { "path": "../src" }
+    ]
+}
+
    
+
    The path property of each reference can point to a directory containing a tsconfig.json file, or to the config file itself (which may have any name).
    
+
    When you reference a project, new things happen:
    
+
      
+
    • Importing modules from a referenced project will instead load its output declaration file (.d.ts)
      • 
+
    • If the referenced project produces an outFile, the output file .d.ts file's declarations will be visible in this project
      • 
+
    • Build mode (see below) will automatically build the referenced project if needed
      • 
+
    
+
    By separating into multiple projects, you can greatly improve the speed of typechecking and compiling, reduce memory usage when using an editor, and improve enforcement of the logical groupings of your program.
    
+
    composite
    
+
    Referenced projects must have the new composite setting enabled.
+This setting is needed to ensure TypeScript can quickly determine where to find the outputs of the referenced project.
+Enabling the composite flag changes a few things:
    
+
      
+
    • The rootDir setting, if not explicitly set, defaults to the directory containing the tsconfig file
      • 
+
    • All implementation files must be matched by an include pattern or listed in the files array. If this constraint is violated, tsc will inform you which files weren't specified
      • 
+
    • declaration must be turned on
      • 
+
    
+
    declarationMaps
    
+
    We've also added support for declaration source maps.
+If you enable --declarationMap, you'll be able to use editor features like "Go to Definition" and Rename to transparently navigate and edit code across project boundaries in supported editors.
    
+
    prepend with outFile
    
+
    You can also enable prepending the output of a dependency using the prepend option in a reference:
    
+
       "references": [
+       { "path": "../utils", "prepend": true }
+   ]
+
    
+
    Prepending a project will include the project's output above the output of the current project.
+This works for both .js files and .d.ts files, and source map files will also be emitted correctly.
    
+
    tsc will only ever use existing files on disk to do this process, so it's possible to create a project where a correct output file can't be generated because some project's output would be present more than once in the resulting file.
+For example:
    
+
       A
+  ^ ^
+ /   \
+B     C
+ ^   ^
+  \ /
+   D
+
    
+
    It's important in this situation to not prepend at each reference, because you'll end up with two copies of A in the output of D - this can lead to unexpected results.
    
+
    Caveats for Project References
    
+
    Project references have a few trade-offs you should be aware of.
    
+
    Because dependent projects make use of .d.ts files that are built from their dependencies, you'll either have to check in certain build outputs or build a project after cloning it before you can navigate the project in an editor without seeing spurious errors.
+We're working on a behind-the-scenes .d.ts generation process that should be able to mitigate this, but for now we recommend informing developers that they should build after cloning.
    
+
    Additionally, to preserve compatibility with existing build workflows, tsc will not automatically build dependencies unless invoked with the --build switch.
+Let's learn more about --build.
    
+
    Build Mode for TypeScript
    
+
    A long-awaited feature is smart incremental builds for TypeScript projects.
+In 3.0 you can use the --build flag with tsc.
+This is effectively a new entry point for tsc that behaves more like a build orchestrator than a simple compiler.
    
+
    Running tsc --build (tsc -b for short) will do the following:
    
+
      
+
    • Find all referenced projects
      • 
+
    • Detect if they are up-to-date
      • 
+
    • Build out-of-date projects in the correct order
      • 
+
    
+
    You can provide tsc -b with multiple config file paths (e.g. tsc -b src test).
+Just like tsc -p, specifying the config file name itself is unnecessary if it's named tsconfig.json.
    
+
    tsc -b Commandline
    
+
    You can specify any number of config files:
    
+
     > tsc -b                            # Use the tsconfig.json in the current directory
+ > tsc -b src                        # Use src/tsconfig.json
+ > tsc -b foo/prd.tsconfig.json bar  # Use foo/prd.tsconfig.json and bar/tsconfig.json
+
    
+
    Don't worry about ordering the files you pass on the commandline - tsc will re-order them if needed so that dependencies are always built first.
    
+
    There are also some flags specific to tsc -b:
    
+
      
+
    • --verbose: Prints out verbose logging to explain what's going on (may be combined with any other flag)
      • 
+
    • --dry: Shows what would be done but doesn't actually build anything
      • 
+
    • --clean: Deletes the outputs of the specified projects (may be combined with --dry)
      • 
+
    • --force: Act as if all projects are out of date
      • 
+
    • --watch: Watch mode (may not be combined with any flag except --verbose)
      • 
+
    
+
    Caveats
    
+
    Normally, tsc will produce outputs (.js and .d.ts) in the presence of syntax or type errors, unless noEmitOnError is on.
+Doing this in an incremental build system would be very bad - if one of your out-of-date dependencies had a new error, you'd only see it once because a subsequent build would skip building the now up-to-date project.
+For this reason, tsc -b effectively acts as if noEmitOnError is enabled for all projects.
    
+
    If you check in any build outputs (.js, .d.ts, .d.ts.map, etc.), you may need to run a --force build after certain source control operations depending on whether your source control tool preserves timestamps between the local copy and the remote copy.
    
+
    MSBuild
    
+
    If you have an msbuild project, you can enable build mode by adding
    
+
        <TypeScriptBuildMode>true</TypeScriptBuildMode>
+
    
+
    to your proj file. This will enable automatic incremental build as well as cleaning.
    
+
    Note that as with tsconfig.json / -p, existing TypeScript project properties will not be respected - all settings should be managed using your tsconfig file.
    
+
    Some teams have set up msbuild-based workflows wherein tsconfig files have the same implicit graph ordering as the managed projects they are paired with.
+If your solution is like this, you can continue to use msbuild with tsc -p along with project references; these are fully interoperable.
    
+
    Guidance
    
+
    Overall Structure
    
+
    With more tsconfig.json files, you'll usually want to use Configuration file inheritance to centralize your common compiler options.
+This way you can change a setting in one file rather than having to edit multiple files.
    
+
    Another good practice is to have a "solution" tsconfig.json file that simply has references to all of your leaf-node projects and sets files to an empty array (otherwise the solution file will cause double compilation of files). Note that starting with 3.0, it is no longer an error to have an empty files array if you have at least one reference in a tsconfig.json file.
    
+
    This presents a simple entry point; e.g. in the TypeScript repo we simply run tsc -b src to build all endpoints because we list all the subprojects in src/tsconfig.json
    
+
    You can see these patterns in the TypeScript repo - see src/tsconfig_base.json, src/tsconfig.json, and src/tsc/tsconfig.json as key examples.
    
+
    Structuring for relative modules
    
+
    In general, not much is needed to transition a repo using relative modules.
+Simply place a tsconfig.json file in each subdirectory of a given parent folder, and add references to these config files to match the intended layering of the program.
+You will need to either set the outDir to an explicit subfolder of the output folder, or set the rootDir to the common root of all project folders.
    
+
    Structuring for outFiles
    
+
    Layout for compilations using outFile is more flexible because relative paths don't matter as much.
+One thing to keep in mind is that you'll generally want to not use prepend until the "last" project - this will improve build times and reduce the amount of I/O needed in any given build.
+The TypeScript repo itself is a good reference here - we have some "library" projects and some "endpoint" projects; "endpoint" projects are kept as small as possible and pull in only the libraries they need.
    
+
+
+                                
+                                
    
+                            
+    
    
+    
    
+        
    
+            
+            
     results matching ""
    
+            
      
+            
+        
      
+        
      
+            
+            
      No results matching ""
      
+            
+        
      
+    
      
+
      
+
+                        
      
+                    
      
+                
+            
      
+
+            
+                
+                
+                    
+                
+                
+                
+                
+                    
+                
+                
+            
+        
+    
      
+
+    
+
      
+
+        
+    
+    
+    
+    
+        
+        
+        
+    
+        
+        
+        
+    
+        
+        
+        
+    
+        
+        
+        
+    
+        
+        
+        
+    
+        
+        
+        
+    
+        
+        
+        
+    
+
+    
+
+    
+
diff --git a/pages/Symbols.html b/pages/Symbols.html
index c79964ab..c77c9346 100644
--- a/pages/Symbols.html
+++ b/pages/Symbols.html
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
    • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
      • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
    • 
+        
    • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
      • 
+    
+        
    • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
      • 
     
-        
    • 
+        
    • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
      • 
     
-        
    • 
+        
    • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
    • 릴리즈 노트
      • 
+        
+        
+    
+        
    • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
      • 
+    
+
+    
 
     
    • 
 
@@ -712,20 +758,20 @@ 
      
                                 
      
                                 
                                 
      소개 (Introduction)
      
-
      ECMAScript 2015에서 시작된 symbol은 number와 string같은 primitive 데이터 타입입니다.
      
-
      symbol 값은 Symbol 생성자를 호출하여 생성됩니다.
      
+
      ECMAScript 2015부터, symbol은 number와 string 같은 기본 자료형입니다.
      
+
      symbol 값들은 Symbol생성자를 호출해서 생성합니다.
      
 
      let sym1 = Symbol();
 
 let sym2 = Symbol("key"); // 선택적 문자열 키
 
      
-
      심볼은 불변이며 고유합니다.
      
+
      심벌은 불변하며 유일합니다.
      
 
      let sym2 = Symbol("key");
 let sym3 = Symbol("key");
 
-sym2 === sym3; // false, 심볼은 고유합니다.
+sym2 === sym3; // false, 심벌은 유일합니다.
 
      
-
      문자열과 마찬가지로 심볼을 객체 프로퍼티의 키로 사용할 수 있습니다.
      
-
      let sym = Symbol();
+
      문자열처럼, 심벌은 객체 프로퍼티의 키로 사용될 수 있습니다.
      
+
      const sym = Symbol();
 
 let obj = {
     [sym]: "value"
@@ -733,7 +779,7 @@ 
      소개 (Introduction)
      
 
 console.log(obj[sym]); // "value"
 
      
-
      심볼을 계산된 프로퍼티 선언과 결합하여 객체 프로퍼티와 클래스 멤버를 선언할 수도 있습니다.
      
+
      심벌은 계산된 프로퍼티 선언과 결합해 객체 프로퍼티와 클래스 멤버를 선언할 수도 있습니다.
      
 
      const getClassNameSymbol = Symbol();
 
 class C {
@@ -745,34 +791,35 @@ 
      소개 (Introduction)
      
 let c = new C();
 let className = c[getClassNameSymbol](); // "C"
 
      
-
      잘 알려진 심볼 (Well-known Symbols)
      
-
      사용자 정의 심볼 외에도 잘 알려진 내장 심볼이 있습니다.
      내장 심볼은 내부 언어 동작을 나타내는 데 사용됩니다.
      
-
      다음은 잘 알려진 심볼 목록입니다.
      
+
      잘 알려진 심벌들 (Well-known Symbols)
      
+
      사용자-정의 심벌 이외에도, 잘 알려진 내장 심벌들이 있습니다.
+내장된 심벌들은 내부 언어 동작을 나타내는 데 사용됩니다.
      
+
      다음은 잘 알려진 심벌 목록입니다:
      
 
      Symbol.hasInstance
      
-
      생성자 객체를 생성자의 인스턴스 중 하나로서 객체를 인식하는지 여부를 판단하는 메서드입니다. instanceof 연산자의 의미로 호출됩니다.
      
+
      생성자 객체가 어떤 객체를 생성자의 인스턴스로 인식하는지 확인하는 메서드입니다. instanceof 연산자로 호출됩니다.
      
 
      Symbol.isConcatSpreadable
      
-
      객체가 Array.prototype.concat에 의해 배열 요소로 병합되어야 함을 나타내는 boolean 값입니다.
      
+
      객체가 자신의 배열 요소를 Array.prototype.concat를 사용하여 직렬로 나타낼 수 있는지를 나타내는 불리언 값입니다.
      
 
      Symbol.iterator
      
-
      객체의 기본 반복자를 반환하는 메서드입니다. for-of 구문에 의해 호출됩니다.
      
+
      객체의 기본 반복자를 반환하는 메서드입니다. for-of 문으로 호출합니다.
      
 
      Symbol.match
      
-
      정규 표현식을 문자열과 비교하는 정규 표현식 메서드입니다. String.prototype.match 메서드로 호출 됩니다.
      
+
      정규식을 문자열과 비교하는 정규식 메서드입니다. String.prototype.match 메서드로 호출합니다.
      
 
      Symbol.replace
      
-
      일치하는 문자열의 부분 문자열을 대체하는 정규 표현식 메서드입니다. String.prototype.replace 메서드로 호출 됩니다.
      
+
      일치하는 부분 문자열을 대체하는 정규식 메서드입니다. String.prototype.replace 메서드로 호출합니다.
      
 
      Symbol.search
      
-
      정규식과 일치하는 문자열에서 인덱스를 반환하는 정규식 메서드입니다. String.prototype.search 메서드로 호출 됩니다.
      
+
      정규식과 일치하는 문자열의 인덱스를 반환하는 정규식 메서드입니다. String.prototype.search 메서드로 호출합니다.
      
 
      Symbol.species
      
-
      파생된 객체를 만드는 데 사용되는 생성자 함수의 프로퍼티 값을 갖는 프로퍼티입니다.
      
+
      파생된 객체를 만드는 생성자 함수 프로퍼티 값입니다.
      
 
      Symbol.split
      
-
      정규 표현식과 일치하는 인덱스에서 문자열을 분할하는 정규 표현식 메서드입니다.
- String.prototype.split 메서드에 의해 호출 됩니다.
      
+
      정규식과 일치하는 인덱스들에 위치한 문자열을 분할하는 정규식 메서드입니다.
+String.prototype.split 메서드로 호출합니다.
      
 
      Symbol.toPrimitive
      
-
      객체를 해당하는 primitive 값으로 변환하는 방법입니다.
-ToPrimitive 추상 동작에 의해 호출됩니다.
      
+
      객체를 해당 기본 값으로 변환하는 메서드입니다.
+ToPrimitive 추상 연산으로 호출합니다.
      
 
      Symbol.toStringTag
      
-
      객체의 기본 문자열 설명을 만드는 데 사용되는 String 값입니다.
-내장 메서드Object.prototype.toString로 호출 합니다.
      
+
      객체의 기본 문자열 설명을 만드는 데 사용되는 문자열 값입니다.
+내장 메소드Object.prototype.toString로 호출합니다.
      
 
      Symbol.unscopables
      
-
      자신의 프로퍼티 이름"을" 가지는 객체는 연관된 객체의 환경 바인딩에서 제외되는 프로퍼티 이름입니다.
      
+
      고유한 프로퍼티 이름들이 연관된 객체의 'with' 환경 바인딩에서 제외된 객체입니다.
      
 
                                 
                                 
      
@@ -816,7 +863,7 @@ 
      No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"심볼","level":"3.11","depth":1,"next":{"title":"이터레이터와 제네레이터","level":"3.12","depth":1,"path":"pages/Iterators and Generators.md","ref":"pages/Iterators and Generators.md","articles":[]},"previous":{"title":"고급 타입","level":"3.10","depth":1,"path":"pages/Advanced Types.md","ref":"pages/Advanced Types.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Symbols.md","mtime":"2019-06-14T05:32:52.248Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"심볼","level":"3.11","depth":1,"next":{"title":"이터레이터와 제네레이터","level":"3.12","depth":1,"path":"pages/Iterators and Generators.md","ref":"pages/Iterators and Generators.md","articles":[]},"previous":{"title":"고급 타입","level":"3.10","depth":1,"path":"pages/Advanced Types.md","ref":"pages/Advanced Types.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Symbols.md","mtime":"2020-04-22T15:29:36.178Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Triple-Slash Directives.html b/pages/Triple-Slash Directives.html
index aa043631..98d08da2 100644
--- a/pages/Triple-Slash Directives.html	
+++ b/pages/Triple-Slash Directives.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
    • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
      • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
    • 
+        
    • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
      • 
+    
+        
    • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
      • 
     
-        
    • 
+        
    • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
      • 
     
-        
    • 
+        
    • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
    • 릴리즈 노트
      • 
+        
+        
+    
+        
    • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
      • 
+    
+
+    
 
     
    • 
 
@@ -711,41 +757,67 @@ 
      
     
                                 
      
                                 
-                                
      트리플-슬래시 지시자는 단일 XML 태그가 포함된 한 줄 주석입니다.
      주석의 내용은 컴파일러 지시자로 사용됩니다.
      
-
      트리플-슬래시 지시자는 포함된 파일의 상단에서만 유효합니다.
      트리플-슬래시 지시자는 다른 트리플-슬래시 지시자를 포함하여 한 줄 또는 여러 줄 주석 앞에 붙을 수 있습니다.
      문 또는 선언 뒤에 나오는 경우 보통의 한 줄 주석으로 간주하며 특별한 의미는 없습니다.
      
+                                
      트리플-슬래시(Triple-slash) 지시어는 단일 XML 태그를 포함하는 한 줄 주석입니다.
+주석의 내용은 컴파일러 지시어로 사용됩니다.
      
+
      트리플-슬래시 지시어는 오직 포함된 파일의 상단에서만 유효합니다.
+트리플-슬래시 지시어는 다른 트리플-슬래시 지시어를 포함한 한 줄 혹은 여러 줄의 주석 앞에만 위치할 수 있습니다.
+만약 문 혹은 선언 뒤에 나오는 경우, 보통의 한 줄 주석으로 여겨지며 어떤 특별한 의미도 갖지 않습니다.
      
 
      /// <reference path="..." />
      
-
      이 중 가장 일반적인 것은 /// <reference path="..." /> 지시자입니다.
      파일 간에 의존성 선언의 역할을 합니다.
      
-
      트리플-슬래시 참조는 컴파일 프로세스에서 추가적인 파일을 포함하도록 컴파일러에 지시합니다.
      
-
      또한 --out 또는 --outFile을 사용할 때 출력을 정렬하는 방법으로도 사용됩니다.
      파일은 전처리 통과 후 입력과 같은 순서의 출력 파일 위치로 방출됩니다.
      
-
      전처리 입력 파일 (Preprocessing input files)
      
-
      컴파일러는 모든 트리플-슬래시 참조 지시자를 해석하기 위해 입력 파일에 대한 전처리 단계를 수행합니다.
      이러한 프로세스 중 컴파일에 추가 파일이 추가됩니다.
      
-
      프로세스는 root files 집합으로 시작합니다.
      이것은 커맨드 라인이나 tsconfig.json 파일의 "files" 리스트에 지정된 파일 이름입니다.
      이러한 루트 파일은 지정된 순서대로 전처리됩니다.
      파일이 목록에 추가되기 전에 파일에 있는 모든 트리플-슬래시 참조가 처리되고 대상이 포함됩니다.
      트리플-슬래시 참조는 파일에서 본 순서대로 우선으로 깊숙하게 분석됩니다.
      
-
      루트가 없는 경우 트리플-슬래시는 포함된 파일에 대한 기준으로 경로를 해석합니다.
      
-
      오류
      
-
      존재하지 않는 파일을 참조하는 것은 오류입니다.
      파일에 자체에 대한 트리플-슬래시 참조가 있는 것은 오류입니다.
      
-
      --noResolve 사용
      
-
      컴파일러 옵션 --noResolve가 지정되면 트리플-슬래시 참조는 무시됩니다.
      새 파일을 추가하거나 제공된 파일의 순서를 변경하지도 않습니다.
      
+
      /// <reference path="..." /> 지시어는 가장 일반적인 지시어입니다.
+파일 간 의존성 선언으로 사용됩니다.
      
+
      트리플-슬래시 참조는 컴파일 프로세스에 추가적인 파일을 포함하도록 컴파일러에게 지시합니다.
      
+
      또한 --out 또는 --outFile을 사용할 때 출력물을 정렬하기 위한 방법으로도 사용됩니다.
+파일은 전처리 통과 후 입력과 동일한 순서로 출력 파일 위치에 생성됩니다.
      
+
      입력 파일 전처리 (Preprocessing input files)
      
+
      컴파일러는 모든 트리플-슬래시 참조 지시어를 분석하기 위해 입력 파일에 대한 전처리를 수행합니다.
+이 과정에서, 추가 파일이 컴파일에 추가됩니다.
      
+
      이 과정은 root files 집합에서 시작합니다;
+이것들은 커맨드-라인이나 tsconfig.json 파일의 "files"목록에 지정된 파일 이름입니다.
+이 루트 파일들은 지정된 순서대로 전처리 됩니다.
+파일이 목록에 추가되기 전, 파일에 있는 모든 트리플-슬래시 참조가 처리되고 그 대상들이 포함됩니다.
+트리플-슬래시 참조는 파일에서 보이는 순서대로 깊이 우선으로 처리됩니다.
      
+
      루트가 없는 경우 트리플-슬래시 참조 경로는 이를 포함하고 있는 파일을 기준으로 처리됩니다.
      
+
      오류 (Errors)
      
+
      존재하지 않는 파일을 참조하는 것은 오류입니다.
+파일이 자기 자신에 대한 트리플-슬래시 참조를 갖는 것은 오류입니다.
      
+
      --noResolve 사용하기 (Using --noResolve)
      
+
      컴파일러 플래그 --noResolve가 지정되면 트리플-슬래시 참조는 무시됩니다; 새 파일을 추가하거나 제공된 파일의 순서를 변경하지 않습니다.
      
 
      /// <reference types="..." />
      
-
      /// <reference path="..." /> 지시자와 마찬가지로 이 지시자도 의존성 선언의 역할을 합니다.
      하지만 /// <reference types="..." />지시자는 패키지에 대한 의존성을 선언합니다.
      
-
      이런 패키지 이름을 해석하는 프로세스는 import문에서 모듈 이름을 해석하는 프로세스와 유사합니다.
      트리플-슬래시 참조 타입 지시자를 생각하는 쉬운 방법은 선언 패키지의 import 입니다.
      
-
      예를 들어 선언 파일에 /// <reference types="node" />를 포함하면 이 파일은 @types/node/index.d.ts에 선언된 이름을 사용합니다.
      따라서 선언 파일과 함께 이 패키지를 컴파일에 포함해야 합니다.
      
-
      이 지시자는 d.ts 파일을 직접 작성할 때만 사용하도록 하세요.
      
-
      컴파일 시 생성된 선언 파일에 대해서는 컴파일러가 /// <reference types="..." />을 자동으로 추가합니다.
      생성된 선언 파일에서 /// <reference types="..." />은 결과 파일이 참조 패키지의 선언을 사용하는 경우에만 추가됩니다.
      
-
      .ts 파일에 대한 @types 패키지에 의존성을 선언하려면 커맨드 라인이나 tsconfig.json에서 --types를 사용하세요.
      
-
      더 자세한 내용은 tsconfig.json 파일에서 @types, typeRoots와 types 사용하기를 보세요.
      
+
      의존성을 선언 역할을 하는 /// <reference path="..." /> 지시어와 유사하게, /// <reference types="..." /> 지시어는 패키지의 의존성을 선언합니다.
      
+
      패키지 이름을 처리하는 과정은 import 문에서 모듈 이름을 처리하는 과정과 유사합니다.
+트리플-슬래시-참조-타입 지시어를 선언 패키지의 import로 생각하면 이해하기 쉽습니다.
      
+
      예를 들어, 선언 파일에 /// <reference types="node" />를 포함하는 것은 이 파일이 @types/node/index.d.ts에 선언된 이름을 사용한다고 선언하며;
+따라서 이 패키지는 선언 파일과 함께 컴파일에 포함되어야 합니다.
      
+
      이 지시어는 d.ts 파일을 직접 작성할 때만 사용하세요.
      
+
      컴파일 중 생성된 선언 파일의 경우, 컴파일러는 자동으로 /// <reference types="..." />를 추가합니다;
+오직 결과 파일이 참조된 패키지의 선언문을 사용하는 경우에만 생성된 선언 파일 안에 /// <reference types="..." /> 가 추가됩니다.
      
+
      .ts 파일에서 @type의 패키지의 의존성을 선언하려면, 커맨드 라인에 --types 을 사용하거나  tsconfig.json을 사용하세요.
+tsconfig.json에서 @types, typeRoots 과 types 사용하기에서 세부 사항을 확인하세요.
      
+
      /// <reference lib="..." />
      
+
      이 지시어는 파일이 명시적으로 기존 내장 lib 파일을 포함하도록 합니다.
      
+
      내장 lib 파일은 tsconfig.json의"lib"컴파일러 옵션과 같은 방식으로 참조됩니다 (예 :lib = "es2015.d"ts가 아닌 lib = "es2015"사용 등).
      
+
      DOM API 또는Symbol 또는 Iterable과 같은 내장 JS 런타임 생성자와 같은 내장 타입에 의존하는 선언 파일 작성자에게는 트리플 슬래시 참조 lib 지시어를 사용하는 것이 권장됩니다. 이전에는 이런 .d.ts 파일은 그런 타입의 전달/중복 선언을 추가했어야 했습니다.
      
+
      예를 들어 컴파일에서 파일 중 하나에 /// <reference lib="es2017.string" />를 추가한 것 것은 --lib es2017.string으로 컴파일 하는 것과 같습니다.
      
+
      /// <reference lib="es2017.string" />
+
+"foo".padStart(4);
+
      
 
      /// <reference no-default-lib="true"/>
      
-
      이 지시자는 파일을 기본 라이브러리로 표시합니다.
      이 주석은 lib.d.ts와 다른 변이들의 맨 위에서 볼 수 있습니다.
      
-
      이 지시자는 컴파일러에 기본 라이브러리 (예: lib.d.ts)를 포함하지 않도록 지시합니다.
      여기에 미치는 영향은 커맨드 라인에 --noLib를 전달하는 것과 비슷합니다.
      
-
      또한 --skipDefaultLibCheck를 넘길 때 컴파일러는 /// <reference no-default-lib="true"/>를 가진 파일 검사만 건너뜁니다.
      
+
      이 지시어는 파일을 기본 라이브러리라고 표시합니다.
+이 주석은 lib.d.ts와 이를 변형한 것들의 맨 상단에서 볼 수 있습니다.
      
+
      이 지시어는 컴파일러에게 기본 라이브러리(예.lib.d.ts)를 컴파일에 포함시키지 않도록 지시합니다.
+이는 커맨드 라인에 --nolib을 넘겨주는 것과 비슷한 영향을 줍니다.
      
+
      또한 --skipDefaultLibCheck를 넘겨주면, 컴파일러가 /// <reference no-default-lib="true"/> 을 갖는 파일만 검사하지 않는다는 것을 유의하세요.
      
 
      /// <amd-module />
      
-
      기본적으로 AMD모듈은 익명으로 생성됩니다.
      이로 인해 번들(예: r.js)과 같은 결과적인 모듈을 처리하는 데 다른 도구를 사용할 경우 문제가 발생할 수 있습니다.
      
-
      amd-module 지시자는 선택적 모듈 이름을 컴파일러에 전달하는 것을 허용합니다:
      
+
      기본적으로 AMD 모듈은 익명으로 생성됩니다.
+이는 모듈로 만들어 내는 과정에 번들러(예. r.js)와 같은 다른 툴을 사용할 경우 문제를 발생시킬 수 있습니다.
      
+
      amd-module 지시어는 컴파일러에게 선택적으로 모듈의 이름을 넘길 수 있도록 해줍니다:
      
 
      amdModule.ts
      
 
      ///<amd-module name="NamedModule"/>
 export class C {
 }
 
      
-
      AMD define을 호출할 때 NamedModule이라는 이름을 모듈에 할당할 것입니다:
      
+
      이는 AMD define 호출의 일부로 NamedModule 이름을 모듈에 할당하는 결과를 낳을 것입니다:
      
 
      amdModule.js
      
 
      define("NamedModule", ["require", "exports"], function (require, exports) {
     var C = (function () {
@@ -758,10 +830,10 @@ 
      amdModule.js
      
 
      
 
      /// <amd-dependency />
      
 
      
-
      주의사항: 이 지시자는 더 이상 사용되지 않습니다(deprecated). 대신 import "moduleName";문을 사용하세요.
      
+
      Note: 이 지시어는 deprecated 되었습니다. 대신 import "moduleName"; 문을 사용하세요.
      
 
      
-
      /// <amd-dependency path="x" /> 결과 모듈의 require 호출에 주입해야하는 non-TS 모듈 의존성에 대해 컴파일러에 알려줍니다.
      
-
      amd-dependency 지시자는 선택적 name 프로퍼티을 가질 수도 있습니다.
      이것은 amd-dependency에 선택적 이름을 전달할 수 있습니다:
      
+
      /// <amd-dependency path="x" />는 컴파일러에게 TS-가 아닌 모듈의 의존성이 결과 모듈의 require 호출에 추가되어야 한다고 알립니다.
      
+
      amd-dependeny 지시어는 선택적으로 name 프로퍼티를 갖습니다; 이로 인해 amd-dependency에 선택적으로 이름을 전달할 수 있습니다:
      
 
      /// <amd-dependency path="legacy/moduleA" name="moduleA"/>
 declare var moduleA:MyType
 moduleA.callStuff()
@@ -814,7 +886,7 @@ 
      No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"트리플-슬래시 지시자","level":"3.21","depth":1,"next":{"title":"JavaScript 파일 타입 검사","level":"3.22","depth":1,"path":"pages/Type Checking JavaScript Files.md","ref":"pages/Type Checking JavaScript Files.md","articles":[]},"previous":{"title":"믹스인","level":"3.20","depth":1,"path":"pages/Mixins.md","ref":"pages/Mixins.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Triple-Slash Directives.md","mtime":"2019-06-14T05:32:52.248Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"트리플-슬래시 지시자","level":"3.21","depth":1,"next":{"title":"JavaScript 파일 타입 검사","level":"3.22","depth":1,"path":"pages/Type Checking JavaScript Files.md","ref":"pages/Type Checking JavaScript Files.md","articles":[]},"previous":{"title":"믹스인","level":"3.20","depth":1,"path":"pages/Mixins.md","ref":"pages/Mixins.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Triple-Slash Directives.md","mtime":"2020-04-22T15:29:36.178Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Type Checking JavaScript Files.html b/pages/Type Checking JavaScript Files.html
index 43545ffe..0bec6968 100644
--- a/pages/Type Checking JavaScript Files.html	
+++ b/pages/Type Checking JavaScript Files.html	
@@ -73,7 +73,7 @@
     
 
     
-    
+    
     
     
     
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
    • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
      • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
    • 
+        
    • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
      • 
+    
+        
    • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
      • 
     
-        
    • 
+        
    • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
      • 
     
-        
    • 
+        
    • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
    • 릴리즈 노트
      • 
+        
+        
+    
+        
    • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
      • 
+    
+
+    
 
     
    • 
 
@@ -711,107 +757,205 @@ 
      
     
                                 
      
                                 
-                                
      TypeScript 2.3 및 이후 버전에서는 --checkJs를 사용하여 .js 파일에서 타입 검사 및 오류 보고 모드를 지원합니다.
      
-
      일부 파일에 // @ts-nocheck 주석을 추가하여 검사하는 것을 건너뛸 수 있습니다.
      반대로 --checkJs를 설정하지 않고 // @ts-check 주석을 추가하여 몇개의 .js 파일 만 검사하도록 선택할 수 있습니다.
      앞 줄에 // @ts-ignore를 추가하여 특정 라인의 오류를 무시할 수도 있습니다.
      
-
      다음은 .ts 파일에서 .js 파일로 작업하는 방법에 주목할만한 차이점입니다:
      
-
      JSDoc에서 타입 사용 (Using types in JSDoc)
      
-
      흔히 .js 파일에서 .ts 파일처럼 타입을 추론할 수 있습니다.
      마찬가지로 타입을 추론할 수 없는 경우 타입 주석을 .ts 파일에서와 같은 방식으로 JSDoc을 사용하여 지정할 수 있습니다.
      
-
      JSDoc 주석은 선언을 추가하여 해당 선언의 타입을 설정하는 데 사용됩니다.
      예를 들어:
      
+                                
      TypeScript 2.3 이상의 버전에서는 --checkJs를 사용해 .js 파일에서 타입 검사 및 오류 보고를 지원합니다.
      
+
      // @ts-nocheck 주석을 달아 일부 파일에서 타입 검사를 건너뛸 수 있으며; 반대로 // @ts-check 주석을 달아 --checkJs를 사용하지 않고 일부 .js 파일에 대해서만 타입 검사를 하도록 선택할 수 있습니다.
+또한 특정 부분의 앞 줄에 // @ts-ignore를 달아 에러를 무시할 수도 있습니다.
+tsconfig.json이 있는 경우, JavaScript 검사는 noImplicitAny, strictNullChecks 등의 엄격한 플래그를 우선시한다는 점을 알아두세요.
+하지만, JavaScript 검사의 상대적인 느슨함 덕분에 엄격한 플래그와 결합하여 사용하는 것은 놀라운 결과를 보여줄 것입니다.
      
+
      .ts 파일과 .js 파일은 타입을 검사하는 방법에 몇 가지 주목할만한 차이점이 있습니다:
      
+
      타입 정보로 사용되는 JSDoc 타입 (JSDoc types are used for type information)
      
+
      .js 파일에서는, 흔히 .ts 파일처럼 타입을 추론해볼 수 있습니다.
+타입을 추론할 수 없는 경우, .ts의 타입 표시와 같은 방법으로 JSDoc을 사용해 이를 지정할 수 있습니다.
+TypeScript와 마찬가지로, --noImplicitAny는 컴파일러가 타입을 유추할 수 없는 부분에서 오류를 보고할 것입니다.
+(확장 가능한 객체 리터럴을 제외하고; 자세한 내용은 아래를 참고하세요.)
      
+
      선언에 JSDoc 표시를 사용하면 해당 선언의 타입을 설정할 수 있습니다. 예를 들면:
      
 
      /** @type {number} */
 var x;
 
-x = 0;      // 좋아요
-x = false;  // 오류: number에 boolean을 할당할 수 없습니다
+x = 0;      // 성공
+x = false;  // 오류: 불리언(boolean)에는 숫자를 할당할 수 없음
+
      
+
      사용 가능한 JSDoc 패턴 목록은 이곳에서 확인할 수 있습니다.
      
+
      클래스 본문의 할당에서 추론된 프로퍼티 (Properties are inferred from assignments in class bodies)
      
+
      ES2015에는 클래스에 프로퍼티를 선언할 수 있는 수단이 없습니다. 프로퍼티는 객체 리터럴과 같이 동적으로 할당됩니다.
      
+
      .js 파일에서, 컴파일러는 클래스 본문 내부에서 할당된 프로퍼티로부터 프로퍼티들을 추론합니다.
+생성자가 정의되어 있지 않거나, 생성자에서 정의된 타입이 undefined나 null이 아닐 경우, 프로퍼티의 타입은 생성자에서 주어진 타입과 동일합니다.
+전자에 해당 프로퍼티의 경우, 할당되었던 모든 값들의 타입을 가진 유니언 타입이 됩니다.
+생성자에 정의된 프로퍼티는 항상 존재하는 것으로 가정하는 반면, 메서드, getter, setter에서만 정의된 프로퍼티는 선택적인 것으로 간주합니다.
      
+
      class C {
+    constructor() {
+        this.constructorOnly = 0
+        this.constructorUnknown = undefined
+    }
+    method() {
+        this.constructorOnly = false // 오류, constructorOnly는 Number 타입임
+        this.constructorUnknown = "plunkbat" // 성공, constructorUnknown의 타입은 string | undefined
+        this.methodOnly = 'ok'  // 성공, 그러나 methodOnly는 undefined 타입 또한 허용됨
+    }
+    method2() {
+        this.methodOnly = true  // 이 또한 성공, methodOnly의 타입은 string | boolean | undefined
+    }
+}
 
      
-
      JavaScript 문서에서 JSDoc 지원에서 지원되는 JSDoc 패턴의 전체 목록을 찾을 수 있습니다.
      
-
      클래스 본문 할당에서 추론된 프로퍼티 선언
      
-
      ES2015/ES6는 클래스에 속성을 선언하는 수단이 없습니다.
      프로퍼티는 객체 리터럴처럼 동적으로 할당됩니다.
      
-
      .js 파일에서 프로퍼티 선언은 클래스 본문 내부의 프로퍼티에 대한 할당에서 유추됩니다.
      프로퍼티 타입은 이러한 할당에서 모든 오른쪽 값의 타입을 결합한 것입니다.
      생성자에 정의된 프로퍼티는 항상 존재한다고 가정하며 메서드, getter 또는 setter에 정의된 프로퍼티는 선택적으로 간주합니다.
      
-
      필요에 따라 프로퍼티 타입을 지정하기 위해 JSDoc으로 프로퍼티를 할당합니다.
      예를 들어:
      
+
      프로퍼티가 클래스 본문에서 설정되지 않았다면, 알 수 없는 것으로 간주합니다.
+클래스에 읽기 전용 프로퍼티가 있는 경우, 생성자에서 선언에 JSDoc을 사용하여 타입을 추가하여 표시합니다.
+이후엔 초기화하더라도 값을 지정할 필요가 없습니다.
      
 
      class C {
     constructor() {
         /** @type {number | undefined} */
-    this.prop = undefined;
+        this.prop = undefined;
+        /** @type {number | undefined} */
+        this.count;
     }
 }
 
-
 let c = new C();
-c.prop = 0;         // 좋아요
-c.prop = "string";  // 오류: number|undefined에 string을 할당할 수 없습니다
+c.prop = 0;          // 성공
+c.count = "string";  // 오류: string 은 number|undefined에 할당할 수 없음
 
      
-
      프로퍼티가 클래스 본문에 설정되지 않으면 알 수 없는 것으로 간주합니다.
      클래스에 읽기 전용 프로퍼티가 있는 경우 생성자에서 초기화로 undefined를 추가하는 것이 좋습니다.
-예. this.prop = undefined;
      
-
      CommonJS 모듈 입력 지원 (CommonJS module input support)
      
-
      .js 파일에서 CommonJS 모듈 포맷은 입력 모듈 포맷으로 허용됩니다.
      exports와 module.exports에 대한 할당은 export 선언으로 인식됩니다.
      비슷하게, require 함수 호출은 모듈 imports로 인식됩니다.
      
-
      예를 들어:
      
-
      // import module "fs"
+
      생성자 함수와 클래스는 동일 (Constructor functions are equivalent to classes)
      
+
      ES2015 이전에는, JavaScript는 클래스 대신 생성자 함수를 사용했습니다.
+컴파일러는 이러한 패턴을 지원하며 생성자 함수를 ES2015 클래스와 동일한 것으로 이해합니다.
+앞서 설명한 프로퍼티 추론 규칙 또한 정확히 같은 방식으로 작용합니다.
      
+
      function C() {
+    this.constructorOnly = 0
+    this.constructorUnknown = undefined
+}
+C.prototype.method = function() {
+    this.constructorOnly = false // 오류
+    this.constructorUnknown = "plunkbat" // 성공, 타입은 string | undefined가 됨
+}
+
      
+
      CommonJS 모듈 지원 (CommonJS modules are supported)
      
+
      .js 파일에서, TypeScript는 CommonJS 모듈 포맷을 이해합니다.
+exports와 module.exports 할당은 export 선언으로 인식됩니다.
+마찬가지로, require 함수 호출은 모듈 import로 인식됩니다. 예를 들어:
      
+
      // `import module "fs"`와 같음
 const fs = require("fs");
 
-
-// export function readFile
+// `export function readFile`과 같음
 module.exports.readFile = function(f) {
-    return fs.readFileSync(f);    
+    return fs.readFileSync(f);
 }
 
      
-
      객체 리터럴에는 제한이 없습니다
      
-
      기본적으로 변수 선언에 객체 리터럴은 선언의 타입을 제공합니다.
      원래 초기화 시에는 지정되지 않은 새 멤버를 추가할 수 없습니다.
      이 규칙은 .js 파일에서 관대한 편입니다. 객체 리터럴은 원래 정의되지 않은 속성을 추가하고 조회할 수 있는 확장 가능한(open-ended) 타입을 가지고 있습니다.
      
-
      예를 들어:
      
+
      JavaScript의 모듈 지원은 TypeScript의 모듈 지원보다 구문적으로 훨씬 관용적입니다.
+따라서 대부분의 할당과 선언의 조합이 지원됩니다.
      
+
      클래스, 함수, 객체 리터럴은 네임스페이스 (Classes, functions, and object literals are namespaces)
      
+
      .js 파일에 있는 클래스는 네임스페이스입니다.
+예를 들어, 다음과 같이 클래스를 중첩하는 데에 사용할 수 있습니다:
      
+
      class C {
+}
+C.D = class {
+}
+
      
+
      그리고 ES2015 이전 코드의 경우, 정적 메서드를 나타내는 데에 사용할 수도 있습니다:
      
+
      function Outer() {
+  this.y = 2
+}
+Outer.Inner = function() {
+  this.yy = 2
+}
+
      
+
      또한 간단한 네임스페이스를 생성하는 데에 사용할 수도 있습니다:
      
+
      var ns = {}
+ns.C = class {
+}
+ns.func = function() {
+}
+
      
+
      다른 번형도 허용됩니다:
      
+
      // 즉시 호출 함수(IIFE)
+var ns = (function (n) {
+  return n || {};
+})();
+ns.CONST = 1
+
+// 전역으로 기본 설정
+var assign = assign || function() {
+  // 여기엔 코드를
+}
+assign.extra = 1
+
      
+
      객체 리터럴은 확장 가능 (Object literals are open-ended)
      
+
      .ts 파일에서, 변수 선언을 초기화하는 객체 리터럴은 선언에 해당 타입을 부여합니다.
+원본 리터럴에 명시되어 있지 않은 새 멤버는 추가될 수 없습니다.
+이 규칙은 .js 파일에선 완화됩니다; 객체 리터럴은 원본에 정의되지 않은 새로운 프로퍼티를 조회하고 추가하는 것이 허용되는 확장 가능한 타입(인덱스 시그니처)을 갖습니다.
+예를 들어:
      
 
      var obj = { a: 1 };
 obj.b = 2;  // 허용됨
 
      
-
      객체 리터럴은 닫힌 객체가 아닌 오픈 maps으로 처리될 수 있도록 하는 기본 인덱스 시그니처 [x:string]: any을 갖습니다.
      
-
      다른 특별한 JS 검사와 마찬가지로, 이 동작은 변수에 대한 JSDoc 타입을 지정하여 변경할 수 있습니다.
      
-
      예를 들어:
      
+
      객체 리터럴은 마치 닫힌 객체가 아니라 열린 맵(maps)으로 다뤄지도록 [x:string]: any와 같은 인덱스 시그니처를 가진 것처럼 동작합니다.
      
+
      다른 특정 JavaScript 검사 동작과 마찬가지로, 해당 동작은 변수에 JSDoc 타입을 지정하여 변경할 수 있습니다. 예를 들어:
      
 
      /** @type {{a: number}} */
 var obj = { a: 1 };
-obj.b = 2;  // 오류, {a: number} 타입은 b 프로퍼티를 가지고 있지 않습니다.
+obj.b = 2;  // 오류, {a: number}타입엔 b 프로퍼티가 없음
+
      
+
      null, undefined 및 빈 배열 이니셜라이저는 any 혹은 any[] 타입 (null, undefined, and empty array initializers are of type any or any[])
      
+
      null 또는 undefined로 초기화된 변수나 매개변수 또는 프로퍼티는, 엄격한 null 검사가 있더라도 any 타입을 갖게 될 것입니다.
+[]로 초기화된 변수나 매개변수 또는 프로퍼티는, 엄격한 null 검사가 있더라도 any[] 타입을 갖게 될 것입니다.
+위에서 설명한 여러 이니셜라이저(initializer)를 갖는 프로퍼티만이 유일한 예외입니다.
      
+
      function Foo(i = null) {
+    if (!i) i = 1;
+    var j = undefined;
+    j = 2;
+    this.l = [];
+}
+var foo = new Foo();
+foo.l.push(foo.i);
+foo.l.push("end");
 
      
-
      함수 매개변수는 기본적으로 선택적입니다. (Function parameters are optional by default)
      
-
      JS에서 매개 변수를 선택적으로 지정할 방법이 없기때문에(기본값을 지정하지 않고).js 파일의 모든 함수 매개 변수는 선택사항으로 간주합니다.
      소수의 인수 호출은 허용됩니다. 
      
-
      인수가 너무 많은 함수를 호출하는 것은 오류라는 점을 주목하는 것이 중요합니다.
      
+
      함수 매개변수는 기본적으로 선택 사항 (Function parameters are optional by default)
      
+
      ES2015 이전의 JavaScript는 선택적인 매개변수를 지정할 방법이 없었기 때문에, .js 파일에선 모든 함수의 매개변수는 선택적인 것으로 간주됩니다.
+선언된 매개변수보다 적은 인수로 호출하는 것이 허용됩니다.
      
+
      그러나 너무 많은 인수를 넣어 호출하면 오류를 일으킨다는 것에 유의하세요.
      
 
      예를 들어:
      
-
      function bar(a, b){
+
      function bar(a, b) {
     console.log(a + " " + b);
 }
 
-bar(1);       // 좋아요, 두번째 인수는 선택사항으로 간주됩니다
+bar(1);       // 성공, 두 번째 인수는 선택 사항임
 bar(1, 2);
-bar(1, 2, 3); // 오류, 인수가 너무 많습니다
+bar(1, 2, 3); // 오류, 인수의 갯수가 너무 많음
 
      
-
      JSDoc 주석이 적용된 함수는 이 규칙에서 제외됩니다.
      선택사항을 명시하기 위해 JSDoc 선택적 매개 변수 구문을 사용하세요.
      
-
      예:
      
+
      JSDoc 표시가 된 함수는 이 규칙에서 예외입니다.
+JSDoc의 선택적 매개변수 구문을 사용하여 선택 사항을 표시할 수 있습니다. 예시:
      
 
      /**
- * @param {string} [somebody] - Somebody의 이름
+ * @param {string} [somebody] - 누군가의 이름
  */
 function sayHello(somebody) {
     if (!somebody) {
         somebody = 'John Doe';
     }
-    alert('Hello ' + somebody);
+    console.log('Hello ' + somebody);
 }
 
 sayHello();
 
      
-
      arguments의 사용으로 추론된 Var-args 매개변수 (Var-args parameter declaration inferred from use of arguments)
      
-
      본문이 arguments 참조에 대한 참조를 갖는 함수는 var-arg 매개변수 (즉,  (...arg: any[]) => any)가 있음을 암시적으로 간주합니다.
      
-
      JSDoc var-arg 구문을 사용하여 인수의 타입을 지정하세요.
      
-
      지정되지 않은 타입 매개 변수의 기본값은any입니다. (Unspecified type parameters default to any)
      
-
      지정되지 않은 제네릭 타입 매개변수는 기본적으로 any로 설정됩니다.
      이런 일이 발생하는 곳은 거의 없습니다:
      
-
      extends에서 (In extends clause):
      
-
      예를 들어, React.Component는 Props와 State의 두 가지 제네릭 타입 매개 변수를 갖도록 정의됩니다.
-.js파일에는 extend 절에 이들을 지정하는 합법적 인 방법이 없습니다..js` 파일에는 extend에 이것들을 지정하는 정당한 방법이 없습니다.
      
-
      기본적으로 타입 인수는 any입니다:
      
+
      arguments 사용으로부터 추론된 var-args 매개변수 선언 (Var-args parameter declaration inferred from use of arguments)
      
+
      arguments 참조를 참조하는 본문을 가진 함수는, 암묵적으로 var-args 매개변수(예: (...arg: any[]) => any)를 갖는 것으로 간주합니다. JSDoc의 var-args 구문을 사용하여 인수의 타입을 지정할 수 있습니다.
      
+
      /** @param {...number} args */
+function sum(/* numbers */) {
+    var total = 0
+    for (var i = 0; i < arguments.length; i++) {
+      total += arguments[i]
+    }
+    return total
+}
+
      
+
      타입이 지정되지 않은 매개변수는 기본적으로 any임 (Unspecified type parameters default to any)
      
+
      JavaScript에는 제네릭 타입의 매개변수를 지정하는 구문이 없으므로, 타입이 지정되지 않은 매개변수는 기본적으로 any 타입입니다.
      
+
      확장 절에서 (In extends clause)
      
+
      예를 들어, React.Component는 Props와 State라는 두 타입의 매개변수를 갖도록 정의되어 있습니다.
+.js 파일에는 이러한 것들을 확장 절에 지정할 수 있는 정당한 방법이 없습니다. 기본적으로 해당 타입 인수는 any가 될 것입니다:
      
 
      import { Component } from "react";
 
 class MyComponent extends Component {
     render() {
-       this.props.b; // 허용됨, this.props는 any 타입이므로
+        this.props.b; // this.props의 타입이 any이므로 허용됨
     }
 }
 
      
-
      JSDoc@augments를 사용하여 사용하여 타입을 명시적으로 지정합니다.
      
-
      예:
      
+
      타입을 명시적으로 지정하려면 JSDoc의 @augments를 사용하세요. 예를 들어:
      
 
      import { Component } from "react";
 
 /**
@@ -819,32 +963,421 @@ 
      extends에서 (In e
  */
 class MyComponent extends Component {
     render() {
-        this.props.b; // 오류: b는 {a:number}에 존재하지 않습니다
+        this.props.b; // 오류: b 는 {a:number}에 속하지 않음
     }
 }
 
      
-
      JSDoc 참조에서 (In JSDoc references)
      
-
      JSDoc의 지정되지 않은 제네릭 타입 인수의 기본값은 any입니다.
      
+
      JSDoc 참조에서 (In JSDoc references)
      
+
      JSDoc의 지정되지 않은 타입 인수는 기본적으로 any입니다:
      
 
      /** @type{Array} */
 var x = [];
 
-x.push(1);        // 좋아요
-x.push("string"); // 좋아요, x는 Array<any>의 타입입니다
-
+x.push(1);        // 성공
+x.push("string"); // 성공, x는 Array<any> 타입임
 
 /** @type{Array.<number>} */
 var y = [];
 
-y.push(1);        // 좋아요
-y.push("string"); // 오류, string은 number에 할당할 수 없습니다
+y.push(1);        // 성공
+y.push("string"); // 오류, string을 number 타입에 할당할 수 없음
 
      
-
      함수 호출에서 (In function calls)
      
-
      제네릭 함수 호출은 제네릭 타입 매개 변수를 추론하기 위한 인수를 사용합니다.
      때때로 이 프로세스는 추론 소스가 부족하여 어떤 타입도 추론하지 못하는 경우가 있습니다.
      이 경우 제네릭 타입 매개 변수는 any로 기본 설정됩니다.
      
-
      예를 들어:
      
+
      함수 호출에서 (In function calls)
      
+
      제네릭 함수의 호출은 인수를 사용해 타입 매개변수를 추론합니다. 때때로 이 과정은 추론 소스가 부족하여 어떠한 타입도 추론하지 못하는 경우가 있습니다; 이러한 경우, 매개변수 타입은 기본적으로 any입니다. 예를 들어:
      
 
      var p = new Promise((resolve, reject) => { reject() });
 
 p; // Promise<any>;
 
      
+
      지원되는 JSDoc (Supported JSDoc)
      
+
      아래의 구성은 JavaScript 파일에서 JSDoc 주석을 사용하여 타입 정보를 제공할 때 지원되는 목록입니다.
      
+
      아래에 명시되지 않은 태그(@async 등)는 아직 지원되지 않는다는 점에 유의하세요.
      
+
        
+
      • @type
        • 
+
      • @param (또는 @arg 또는 @argument)
        • 
+
      • @returns (또는 @return)
        • 
+
      • @typedef
        • 
+
      • @callback
        • 
+
      • @template
        • 
+
      • @class (또는 @constructor)
        • 
+
      • @this
        • 
+
      • @extends (또는 @augments)
        • 
+
      • @enum
        • 
+
      
+
      대부분의 태그의 의미는 usejsdoc.org에서 설명하는 태그의 의미와 같습니다.
+아래의 코드는 차이점을 설명하고 각 태그의 사용 예시를 설명합니다.
      
+
      @type
      
+
      "@type" 태그를 사용하고 타입 이름을 참조(원래 TypeScript의 선언에 정의된 것 또는 JSDoc의 "@typedef" 태그 중 하나)할 수 있습니다.
+모든 TypeScript의 타입, 대부분의 JSDoc 타입 중 어떤 것이든 사용할 수 있습니다.
      
+
      /**
+ * @type {string}
+ */
+var s;
+
+/** @type {Window} */
+var win;
+
+/** @type {PromiseLike<string>} */
+var promisedString;
+
+// HTML 요소를 DOM 프로퍼티로 지정할 수 있음
+/** @type {HTMLElement} */
+var myElement = document.querySelector(selector);
+element.dataset.myData = '';
+
      
+
      @type은 유니언 타입으로 지정할 수 있습니다; 예를 들어, 문자열과 불리언 중 어떤 것이든 될 수 있습니다.
      
+
      /**
+ * @type {(string | boolean)}
+ */
+var sb;
+
      
+
      유니언 타입에는 괄호가 선택 사항이라는 점에 유의하세요.
      
+
      /**
+ * @type {string | boolean}
+ */
+var sb;
+
      
+
      다양한 구문을 사용하여 배열 타입을 지정할 수도 있습니다:
      
+
      /** @type {number[]} */
+var ns;
+/** @type {Array.<number>} */
+var nds;
+/** @type {Array<number>} */
+var nas;
+
      
+
      또한 객체 리터럴 타입을 지정할 수도 있습니다.
+예를 들어, 프로퍼티 'a' (string) 와 'b' (number)를 갖는 오브젝트라면 다음과 같은 구문을 사용할 수 있습니다.
      
+
      /** @type {{ a: string, b: number }} */
+var var9;
+
      
+
      표준 JSDoc 구문 또는 TypeScript 구문을 통해 문자열 혹은 숫자 인덱스 시그니처를 사용하여 유사-맵 혹은 유사-배열 오브젝트를 지정할 수도 있습니다.
      
+
      /**
+ * 임의의 `string` 프로퍼티를 `number`에 매핑하는 유사-맵 객체.
+ *
+ * @type {Object.<string, number>}
+ */
+var stringToNumber;
+
+/** @type {Object.<number, object>} */
+var arrayLike;
+
      
+
      앞의 두 타입은 TypeScript의 { [x: string]: number } 그리고 { [x: number]: any }와 동일합니다. 컴파일러는 두 구문을 모두 이해할 것입니다.
      
+
      함수 타입은 TypeScript 또는 클로저 구문을 사용하여 지정할 수 있습니다:
      
+
      /** @type {function(string, boolean): number} Closure 구문 */
+var sbn;
+/** @type {(s: string, b: boolean) => number} TypeScript 구문 */
+var sbn2;
+
      
+
      혹은 단순히 지정되지 않은 Function 타입을 사용할 수도 있습니다:
      
+
      /** @type {Function} */
+var fn7;
+/** @type {function} */
+var fn6;
+
      
+
      Closure의 다른 타입 또한 동작합니다:
      
+
      /**
+ * @type {*} - 어떠한 타입이든 될 수 있음
+ */
+var star;
+/**
+ * @type {?} - 식별되지 않은 타입 ('any'와 같음)
+ */
+var question;
+
      
+
      캐스트 (Casts)
      
+
      TypeScript는 클로저의 캐스트(cast) 구문을 차용합니다.
+이는 괄호화된 표현식 앞에 @type 태그를 사용하여 다른 타입으로의 캐스트를 가능케 합니다.
      
+
      /**
+ * @type {number | string}
+ */
+var numberOrString = Math.random() < 0.5 ? "hello" : 100;
+var typeAssertedNumber = /** @type {number} */ (numberOrString)
+
      
+
      타입 import (Import types)
      
+
      타입 import를 사용하여 다른 파일의 선언을 가져올 수도 있습니다.
+이 구문은 TypeScript에 특화된 것이며 JSDoc 표준과는 조금 다릅니다:
      
+
      /**
+ * @param p { import("./a").Pet }
+ */
+function walk(p) {
+    console.log(`Walking ${p.name}...`);
+}
+
      
+
      타입 import는 타입 별칭 선언에서도 쓰일 수 있습니다:
      
+
      /**
+ * @typedef { import("./a").Pet } Pet
+ */
+
+/**
+ * @type {Pet}
+ */
+var myPet;
+myPet.name;
+
      
+
      타입을 모르거나 입력하기 귀찮은 큰 타입이 있을 경우, 타입 import를 사용하여 모듈에서 값의 타입을 가져올 수 있습니다:
      
+
      /**
+ * @type {typeof import("./a").x }
+ */
+var x = require("./a").x;
+
      
+
      @param and @returns
      
+
      @param은 @type과 같은 종류의 구문을 사용하지만, 매개변수의 이름이 추가됩니다.
+매개변수는 이름을 대괄호로 둘러싸서 선택적으로 선언할 수 있습니다:
      
+
      // 매개변수는 다양한 형태의 구문으로 선언될 수 있음
+/**
+ * @param {string}  p1 - 문자열 매개변수.
+ * @param {string=} p2 - 선택적 문자열 매개변수 (클로저 구문)
+ * @param {string} [p3] - 또다른 선택적 매개변수 (JSDoc 구문).
+ * @param {string} [p4="test"] - 기본값을 가진 선택적 매개변수
+ * @return {string} 결과
+ */
+function stringsStringStrings(p1, p2, p3, p4){
+  // TODO
+}
+
      
+
      마찬가지로, 함수의 반환 타입으로는:
      
+
      /**
+ * @return {PromiseLike<string>}
+ */
+function ps(){}
+
+/**
+ * @returns {{ a: string, b: number }} - '@returns'과 '@return' 모두 사용 가능
+ */
+function ab(){}
+
      
+
      @typedef, @callback, and @param
      
+
      @typedef를 사용해 복잡한 타입을 정의할 수 있습니다.
+@param과 비슷한 구문으로 동작합니다.
      
+
      /**
+ * @typedef {Object} SpecialType - 'SpecialType'이라는 새 타입을 생성
+ * @property {string} prop1 - SpecialType의 문자열 프로퍼티
+ * @property {number} prop2 - SpecialType의 숫자 프로퍼티
+ * @property {number=} prop3 - SpecialType의 선택적 숫자 프로퍼티
+ * @prop {number} [prop4] - SpecialType의 선택적 숫자 프로퍼티
+ * @prop {number} [prop5=42] - SpecialType의 기본값을 가진 선택적 숫자 프로퍼티
+ */
+/** @type {SpecialType} */
+var specialTypeObject;
+
      
+
      첫 번째 줄에 object나 Object를 사용할 수 있습니다.
      
+
      /**
+ * @typedef {object} SpecialType1 - 'SpecialType1'이라는 새 타입 생성
+ * @property {string} prop1 - SpecialType1의 문자열 프로퍼티
+ * @property {number} prop2 - SpecialType1의 숫자 프로퍼티
+ * @property {number=} prop3 - SpecialType1의 선택적 숫자 프로퍼티
+ */
+/** @type {SpecialType1} */
+var specialTypeObject1;
+
      
+
      @param은 일회성인 타입 지정에 대한 비슷한 구문을 허용합니다.
+중첩된 프로퍼티 이름 앞엔 매개변수 이름을 붙여야 함을 유의하세요:
      
+
      /**
+ * @param {Object} options - 해당 형태는 위의 SpecialType과 동일
+ * @param {string} options.prop1
+ * @param {number} options.prop2
+ * @param {number=} options.prop3
+ * @param {number} [options.prop4]
+ * @param {number} [options.prop5=42]
+ */
+function special(options) {
+  return (options.prop4 || 1001) + options.prop5;
+}
+
      
+
      @callback은 @typedef와 비슷합니다만, 객체 타입 대신 함수의 타입을 지정합니다:
      
+
      /**
+ * @callback Predicate
+ * @param {string} data
+ * @param {number} [index]
+ * @returns {boolean}
+ */
+/** @type {Predicate} */
+const ok = s => !(s.length % 2);
+
      
+
      물론, 이러한 유형 중 어떤 것이라도 단일 라인의 @typedef TypeScript 구문을 사용해 선언될 수 있습니다:
      
+
      /** @typedef {{ prop1: string, prop2: string, prop3?: number }} SpecialType */
+/** @typedef {(data: string, index?: number) => boolean} Predicate */
+
      
+
      @template
      
+
      @template 태그로 제네릭 타입을 선언할 수 있습니다:
      
+
      /**
+ * @template T
+ * @param {T} x - 리턴 타입까지 사용되는 제네릭 매개변수
+ * @return {T}
+ */
+function id(x){ return x }
+
      
+
      콤마 또는 여러 태그를 사용하여 여러 매개변수 타입을 선언할 수 있습니다:
      
+
      /**
+ * @template T,U,V
+ * @template W,X
+ */
+
      
+
      타입 매개변수 이름 앞에 타입 제약 조건을 지정할 수도 있습니다.
+목록의 첫 번째 매개변수의 타입만 제한됩니다:
      
+
      /**
+ * @template {string} K - K는 문자열 혹은 문자열 리터럴이어야만 함
+ * @template {{ serious(): string }} Seriousalizable - serious 메서드를 가져야만 함
+ * @param {K} key
+ * @param {Seriousalizable} object
+ */
+function seriousalize(key, object) {
+  // ????
+}
+
      
+
      @constructor
      
+
      컴파일러는 this-프로퍼티 할당을 기반으로 생성자 함수를 추론합니다만, @constructor 태그를 추가하여 보다 엄격한 검사와 더 나은 제안이 되도록 만들 수 있습니다.
      
+
      /**
+ * @constructor
+ * @param {number} data
+ */
+function C(data) {
+  this.size = 0;
+  this.initialize(data); // 이니셜라이저에 문자열이 들어갈 경우, 오류 발생 가능
+}
+/**
+ * @param {string} s
+ */
+C.prototype.initialize = function (s) {
+  this.size = s.length
+}
+
+var c = new C(0);
+var result = C(1); // C는 새 인스턴스로만 호출해야 함
+
      
+
      @constructor를 사용하면, this는 C의 생성자 함수 내부에서 검사되므로, initailize 메서드에 대하여 알 수 있을 것이며 숫자를 넘길 경우 오류가 발생할 것입니다. 또한 C를 생성하지 않고 호출할 경우 오류를 일으킬 것입니다.
      
+
      불행하게도, 이는 호출 가능한 생성자 함수는 @constructor를 사용할 수 없다는 것을 의미합니다.
      
+
      @this
      
+
      컴파일러는 대게 작업할 컨텍스트가 있을 때 this의 타입을 알아낼 수 있습니다. 그렇지 않은 경우, @this를 사용해 this의 타입을 명시할 수 있습니다:
      
+
      /**
+ * @this {HTMLElement}
+ * @param {*} e
+ */
+function callbackForLater(e) {
+    this.clientHeight = parseInt(e) // 잘 되어야 함!
+}
+
      
+
      @extends
      
+
      JavaScript 클래스엔 제네릭 기초 클래스를 확장할 때, 매개변수가 어떤 타입이 되어야 하는지 지정할 곳이 없습니다. @extends 태그는 해당 매개변수 타입에 대한 위치를 제공합니다:
      
+
      /**
+ * @template T
+ * @extends {Set<T>}
+ */
+class SortableSet extends Set {
+  // ...
+}
+
      
+
      @extends는 클래스에서만 작동한다는 점을 알아두세요. 현재로서는, 생성자 함수가 클래스를 확장하는 방법은 없습니다.
      
+
      @enum
      
+
      @enum 태그를 사용하면 해당 멤버가 모두 지정된 타입인 객체 리터럴을 생성할 수 있습니다. 대부분의 JavaScript 객체 리터럴과는 다르게, 다른 멤버는 허용되지 않습니다.
      
+
      /** @enum {number} */
+const JSDocState = {
+  BeginningOfLine: 0,
+  SawAsterisk: 1,
+  SavingComments: 2,
+}
+
      
+
      @enum은 TypeScript의 enum 과는 꽤 다르며, 훨씬 단순하다는 점에 유의하세요. 그러나 TypeScript의 열거형과는 달리, @enum은 어떠한 타입이든 가질 수 있습니다:
      
+
      /** @enum {function(number): number} */
+const Math = {
+  add1: n => n + 1,
+  id: n => -n,
+  sub1: n => n - 1,
+}
+
      
+
      다른 예제들 (More examples)
      
+
      var someObj = {
+  /**
+   * @param {string} param1 - 프로퍼티 할당에 대한 Docs
+   */
+  x: function(param1){}
+};
+
+/**
+ * 변수 할당에 대한 docs처럼
+ * @return {Window}
+ */
+let someFunc = function(){};
+
+/**
+ * 클래스 메서드
+ * @param {string} greeting 사용할 인사말
+ */
+Foo.prototype.sayHi = (greeting) => console.log("Hi!");
+
+/**
+ * 화살표 함수 표현
+ * @param {number} x - A multiplier
+ */
+let myArrow = x => x * x;
+
+/**
+ * JSX의 무상태 함수 컴포넌트에서도 사용됨.
+ * @param {{a: string, b: number}} test - Some param
+ */
+var fc = (test) => <div>{test.a.charAt(0)}</div>;
+
+/**
+ * 클로저 구문을 사용하여, 매개변수가 클래스 생성자가 될 수 있음.
+ *
+ * @param {{new(...args: any[]): object}} C - 등록할 클래스
+ */
+function registerClass(C) {}
+
+/**
+ * @param {...string} p1 - A 'rest' arg (array) of strings. ('any'로 취급됨)
+ */
+function fn10(p1){}
+
+/**
+ * @param {...string} p1 - A 'rest' arg (array) of strings. ('any'로 취급됨)
+ */
+function fn9(p1) {
+  return p1.join();
+}
+
      
+
      지원되지 않을 것으로 알려진 패턴들 (Patterns that are known NOT to be supported)
      
+
      생성자 함수처럼, 값 공간(value space)에 있는 객체를 타입으로 참조하는 것은 객체가 타입을 생성하지 않는 한 작동하지 않습니다.
      
+
      function aNormalFunction() {
+
+}
+/**
+ * @type {aNormalFunction}
+ */
+var wrong;
+/**
+ * 'typeof' 대신 사용:
+ * @type {typeof aNormalFunction}
+ */
+var right;
+
      
+
      접미사는 객체 리터럴 유형의 프로퍼티 유형과 동일하며 선택적 프로퍼티를 지정하지 않습니다:
      
+
      /**
+ * @type {{ a: string, b: number= }}
+ */
+var wrong;
+/**
+ * 프로퍼티 이름에 물음표 접미사 사용
+ * @type {{ a: string, b?: number }}
+ */
+var right;
+
      
+
      Nullable 타입은 strictNullChecks이 활성화되어있는 때만 의미가 있습니다.
      
+
      /**
+ * @type {?number}
+ * With strictNullChecks: true -- number | null
+ * With strictNullChecks: off  -- number
+ */
+var nullable;
+
      
+
      Nullable이 아닌 타입은 의미가 없으며 원래의 타입으로 취급됩니다:
      
+
      /**
+ * @type {!number}
+ * 단순히 숫자 타입을 갖게 됨
+ */
+var normal;
+
      
+
      JSDoc의 타입 시스템과는 다르게, TypeScript는 null 값을 포함하는지, 안 하는지에 대해서만 표시할 수 있습니다.
+명시적인 non-nullability는 없습니다 -- strictNullChecks이 활성화되어 있다면, number는 nullable이 아닐 것입니다.
+활성화되어있지 않다면, number는 nullable 일 것입니다.
      
 
                                 
                                 
      
@@ -877,7 +1410,7 @@ 
      No results matching "
                 
                 
-                
+                
                     
                 
                 
@@ -888,7 +1421,7 @@ 
      No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"JavaScript 파일 타입 검사","level":"3.22","depth":1,"next":{"title":"소개","level":"4.1","depth":1,"path":"pages/declaration files/Introduction.md","ref":"pages/declaration files/Introduction.md","articles":[]},"previous":{"title":"트리플-슬래시 지시자","level":"3.21","depth":1,"path":"pages/Triple-Slash Directives.md","ref":"pages/Triple-Slash Directives.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Type Checking JavaScript Files.md","mtime":"2019-06-14T05:32:52.249Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"JavaScript 파일 타입 검사","level":"3.22","depth":1,"next":{"title":"유틸리티 타입","level":"3.23","depth":1,"path":"pages/Utility Types.md","ref":"pages/Utility Types.md","articles":[]},"previous":{"title":"트리플-슬래시 지시자","level":"3.21","depth":1,"path":"pages/Triple-Slash Directives.md","ref":"pages/Triple-Slash Directives.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Type Checking JavaScript Files.md","mtime":"2020-04-22T15:29:36.179Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Type Compatibility.html b/pages/Type Compatibility.html
index fdaf482b..e9841fec 100644
--- a/pages/Type Compatibility.html	
+++ b/pages/Type Compatibility.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
    • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
      • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
    • 
+        
    • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
      • 
+    
+        
    • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
      • 
     
-        
    • 
+        
    • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
      • 
     
-        
    • 
+        
    • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
    • 릴리즈 노트
      • 
+        
+        
+    
+        
    • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
      • 
+    
+
+    
 
     
    • 
 
@@ -712,8 +758,10 @@ 
      
                                 
      
                                 
                                 
      소개 (Introduction)
      
-
      TypeScript의 타입 호환성은 구조적 하위 타입을 기반으로합니다.
      구조적 타이핑은 멤버에 따라 타입을 관계시키는 방법입니다.
      이것은 이름뿐인 타이핑과 대조적입니다.
      
-
      다음 코드를 살펴보세요 :
      
+
      TypeScript의 타입 호환성은 구조적 서브 타이핑(subtyping)을 기반으로 합니다.
+구조적 타이핑이란 오직 멤버만으로 타입을 관계시키는 방식입니다.
+명목적 타이핑(nominal typing) 과는 대조적입니다.
+다음 코드를 살펴보겠습니다:
      
 
      interface Named {
     name: string;
 }
@@ -723,75 +771,74 @@ 
      소개 (Introduction)
      
 }
 
 let p: Named;
-// 구조적 타이핑이니까 좋아요 
+// 성공, 구조적 타이핑이기 때문입니다.
 p = new Person();
 
      
-
      C# 또는 Java 같은 명사적인 언어에서는 person 클래스가 자신을 Named 인터페이스의 구현체로 명시적으로 기술하지 않기 때문에 동일한 코드가 오류가 될 수 있습니다.
      
-
      TypeScript의 구조적인 타입 시스템은 일반적으로 JavaScript 코드가 작성된 방식에 따라 설계되었습니다.
      
-
      JavaScript는 함수 표현식이나 객체 리터럴과 같은 익명의 객체를 광범위하게 사용하기 때문에 이름뿐인 구조적 타입 시스템 대신 JavaScript 라이브러리에서 발견되는 관계의 타입을 표현하는 것이 훨씬 자연스럽습니다.
      
-
      안전성에 대한 노트 (A Note on Soundness)
      
-
      TypeScript의 타입 시스템을 사용하면 완료시 알 수 없는 특정 작업을 안전하게 수행할 수 있습니다.
      타입 시스템에 이 프로퍼티가 있으면 그것은 "타당"한 것이 아니라고 합니다.
      
-
      TypeScript에서 부적절한 동작을 허용하는 곳을 신중하게 고려했으며 이 문서 전체에서 이러한 상황이 발생하는 곳과 그 뒤에있는 숨겨진 동기 부여 시나리오에 대해 설명합니다.
      
+
      C#이나 Java와 같은 명목적-타입 언어에서는 Person 클래스는 Named 인터페이스를 명시적인 구현체로 기술하지 않았기 때문에 해당 코드는 오류를 발생시킵니다.
      
+
      TypeScript의 구조적 타입 시스템은 JavaScript 코드의 일반적인 작성 방식에 따라서 설계되었습니다.
+JavaScript는 함수 표현식이나 객체 리터럴 같은 익명 객체를 광범위하게 사용하기 때문에 JavaScript에서 발견되는 관계의 타입을 명목적 타입 시스템보다는 구조적 타입 시스템을 이용하여 표현하는 것이 훨씬 더 자연스럽습니다.
      
+
      건전성에 대한 참고사항 (A Note on Soundness)
      
+
      TypeScript의 타입 시스템은 컴파일 시간에 확인할 수 없는 특정 작업을 안전하게 수행할 수 있습니다. 타입 시스템이 이런 특성을 갖고 있을 때, "건전"하지 않다고 말합니다. TypeScript에서 건전하지 못한 곳을 허용하는 부분을 신중하게 고려했으며, 이 문서 전체에서 이러한 상황이 발생하는 곳과 유발하는 시나리오에 대해 설명합니다.
      
 
      시작하기 (Starting out)
      
-
      TypeScript의 구조 타입 시스템에 대한 기본적인 규칙은 y가 적어도x와 같은 멤버를 가지고 있다면 x는 y와 호환된다는 것입니다.
      
-
      예를 들어:
      
+
      TypeScript의 구조적 타입 시스템의 기본 규칙은 y가 최소한 x와 동일한 멤버를 가지고 있다면 x와 y는 호환된다는 것입니다. 예를 들어:
      
 
      interface Named {
     name: string;
 }
 
 let x: Named;
-// y의 추론된 타입은 { name: string; location: string; } 입니다
+// y의 추론된 타입은 { name: string; location: string; } 입니다.
 let y = { name: "Alice", location: "Seattle" };
 x = y;
 
      
-
      y가 x에 할당될 수 있는지를 검사하기 위해 컴파일러는 x의 각 프로퍼티를 검사하여 y에서 상응하는 호환되는 프로퍼티를 찾습니다.
      
-
      이 경우 y는 문자열인 name 멤버를 가져야합니다. 그렇기 때문에 할당이 허용됩니다.
      
-
      함수 호출 인수를 검사할 때 다음과 같은 할당 규칙이 사용됩니다 :
      
+
      y를 x에 할당할 수 있는지 검사하기 위해, 컴파일러는 x의 각 프로퍼티를 검사하여 y에서 상응하는 호환 가능한 프로퍼티를 찾습니다.
+이 경우, y는 name이라는 문자열 멤버를 가지고 있어야 합니다. 그러므로 할당이 허용됩니다.
      
+
      함수 호출 인수를 검사할 때 동일한 할당 규칙이 적용됩니다:
      
 
      function greet(n: Named) {
-    alert("Hello, " + n.name);
+    console.log("Hello, " + n.name);
 }
-greet(y); // 좋아요
+greet(y); // 성공
 
      
-
      y는 별도의 location 프로퍼티를 가지고 있지만  이로 인해 오류가 생기는 것은 아니라는 점에 유의한다.  
      
-
      호환성을 검사할 때 대상의 타입 (이 경우 Named) 멤버만 고려됩니다.
      
-
      이 비교 프로세스는 재귀적으로 진행되어 각 구성원 및 하위 멤버의 유형을 탐색합니다.
      
+
      y는 location 프로퍼티를 추가적으로 가지고 있지만 오류를 발생시키지 않는 점에 유의합니다.
+호환성을 검사할 때는 오직 대상 타입의 멤버(이 경우는 Named)만 고려됩니다.
      
+
      이 비교하는 과정은 재귀적으로 각 멤버와 하위-멤버의 타입을 탐색하면서 진행됩니다.
      
 
      두 함수 비교 (Comparing two functions)
      
-
      원시적인 타입과 객체 타입을 비교하는 것은 비교적 간단하지만 호환성이 있는 것으로 간주되어야 하는 함수의 종류에 대한 질문은 좀 더 복잡합니다.
      
-
      먼저 매개변수 목록에서만 다른 두 함수의 기본 예제를 살펴보겠습니다 :
      
+
      원시 타입과 객체 타입을 비교하는 것은 비교적 간단하지만, 어떤 유형의 함수들이 호환될 수 있는지에 대한 질문은 조금 더 복잡합니다.
+먼저 매개변수 목록에서만 다른 두 함수의 기본 예제를 살펴보겠습니다:
      
 
      let x = (a: number) => 0;
 let y = (b: number, s: string) => 0;
 
-y = x; // 좋아요
+y = x; // 성공
 x = y; // 오류
 
      
-
      x가 y에 할당될 수 있는지 확인하기 위해 우선 매개 변수 목록을 살펴봅니다.
-x의 각 매개 변수는 호환 가능한 타입을 가진 y에서 상응하는 매개 변수를 가져야합니다.
      
-
      매개 변수 이름은 고려되지 않으며 타입만 고려됩니다.
      이 경우x의 모든 매개 변수는y에 상응하는 호환 매개 변수를 가지므로 할당이 허용됩니다.
      
-
      y에는 x가 필요로 하지 않는 두 번째 매개 변수가 있어 할당이 허용되지 않으므로 오류입니다.
      
-
      y = x 예시와 같은 '버려지는' 매개변수를 허용하는지 이유가 의심스러울겁니다.
      이 할당이 허용되는 이유는 JavaScript에서 추가적인 함수 매개 변수를 무시하는 것이 상당히 흔한 일이기 때문입니다.  
      
-
      예를 들어 Array#forEach는 콜백 함수에 세 개의 매개 변수를 제공합니다 : 배열 요소와 해당 인덱스 및 포함된 배열
-그럼에도 불구하고 첫 번째 매개 변수 만 사용하는 콜백을 제공하는 것은 매우 유용합니다 :
      
+
      x를 y에 할당할 수 있는지 검사하기 위해, 먼저 매개변수 목록을 살펴봅니다.
+x의 각 매개변수는 호환 가능한 타입을 가진 y의 해당 매개변수를 가져야 합니다.
+매개변수의 이름은 고려하지 않고 타입만 검사한다는 점에 유의하세요.
+이 경우에는 x의 모든 매개변수는 y에 상응하는 호환 가능한 매개변수를 가지므로 할당이 허용됩니다.
      
+
      두 번째 할당은 y는 x에 없는 두 번째 필수적인 매개변수를 가지고 있기 때문에 할당이 허용되지 않아 오류가 발생합니다.
      
+
      y = x의 예제에서처럼 매개변수를 '버리는' 것이 허용되는 이유가 궁금할 수 있습니다.
+이러한 할당이 허용되는 이유는 함수의 추가 매개변수를 무시하는 것이 실제로 JavaScript에선 매우 일반적이기 때문입니다.
+예를 들어, Array#forEach는 콜백 함수에게 3 가지 매개변수인 배열 요소, 그 요소의 인덱스 그리고 이것을 포함하는 배열을 제공합니다.
+그럼에도 불구하고 첫 번째 매개변수만 사용하는 콜백을 제공하는 것은 매우 유용합니다:
      
 
      let items = [1, 2, 3];
 
-// 이러한 추가 매개 변수를 강제로 사용하지 마세요
+// 추가 매개변수를 강제로 사용하지 마세요.
 items.forEach((item, index, array) => console.log(item));
 
-// 괜찮을 거에요!
+// 괜찮습니다!
 items.forEach(item => console.log(item));
 
      
-
      이제 타입 유형에 따라 다른 두 함수를 사용하여 반환 타입을 처리하는 방법을 살펴보겠습니다:
      
+
      반환 타입이 다른 두 함수를 사용하여 반환 타입이 어떻게 처리되는지 살펴보겠습니다:
      
 
      let x = () => ({name: "Alice"});
 let y = () => ({name: "Alice", location: "Seattle"});
 
-x = y; // 좋아요
-y = x; // x에 location 프로퍼티가 없기 때문에 오류
+x = y; // 성공
+y = x; // 오류, x()는 location 프로퍼티가 없습니다.
 
      
-
      타입 시스템은 소스 함수의 반환 타입이 대상 타입의 반환 타입의 서브 타입이되도록 강제합니다.
      
+
      타입 시스템은 원본 함수의 반환 타입이 대상 타입의 반환 타입의 하위 타입이 되도록 합니다.
      
 
      함수 매개변수의 Bivariance (Function Parameter Bivariance)
      
-
      함수 매개 변수의 타입을 비교할 때 원본 매개 변수가 대상 매개 변수에 할당 가능하거나 그 반대일 경우 할당이 성공합니다.
      
-
      이것은 호출한 측에서 더 특수화된 타입을 취하는 함수를 제공하게 될 수도 있지만 덜 특수화된 타입의 함수를 호출할 수 있기 때문에 바람직하지 않습니다.
      
-
      실제로 이런 종류의 오류는 드물기 때문에 이를 통해 많은 일반적인 JavaScript 패턴을 사용할 수 있습니다. 
      
-
      간단한 예제:
      
+
      함수 매개변수의 타입을 비교할 때, 원본 매개변수가 대상 매개변수에 할당이 가능하거나 이 반대여도 할당은 성공합니다.
+이것은 호출한 측에서 더 특수한 타입을 취하여 함수를 제공할 수도 있지만, 덜 특수화된 타입의 함수를 호출할 수 있기 때문에 바람직하지 않습니다.
+실제로 이런 종류의 오류는 드물지만 이는 많은 일반적인 JavaScript 패턴들을 사용할 수 있게 합니다. 간단한 예제:
      
 
      enum EventType { Mouse, Keyboard }
 
 interface Event { timestamp: number; }
@@ -802,36 +849,38 @@ 
      /* ... */
 }
 
-// 부적절하지만 유익하고 일반적인
+// 바람직하진 않지만 유용하고 일반적임
 listenEvent(EventType.Mouse, (e: MouseEvent) => console.log(e.x + "," + e.y));
 
-// 안정성에서 바람직하지 않은 대안
-listenEvent(EventType.Mouse, (e: Event) => console.log((<MouseEvent>e).x + "," + (<MouseEvent>e).y));
-listenEvent(EventType.Mouse, <(e: Event) => void>((e: MouseEvent) => console.log(e.x + "," + e.y)));
+// 건전성 측면에서 바람직하지 않은 대안
+listenEvent(EventType.Mouse, (e: Event) => console.log((e as MouseEvent).x + "," + (e as MouseEvent).y));
+listenEvent(EventType.Mouse, ((e: MouseEvent) => console.log(e.x + "," + e.y)) as (e: Event) => void);
 
-//그래도 허용되지 않습니다(명확한 오류). 완전히 호환되지 않는 유형에 대해 적용되는 타입 안전성(Type safety)
+// 여전히 허용되지 않음 (명확한 오류). 완전히 호환되지 않는 타입에 적용되는 타입 안전성(Type safety)
 listenEvent(EventType.Mouse, (e: number) => console.log(e));
 
      
-
      선택적 매개 변수와 나머지 매개 변수 (Optional Parameters and Rest Parameters)
      
-
      호환성을 위한 함수를 비교할 때 선택적 매개 변수와 필수 매개 변수는 서로 바꿔서 사용할 수 있습니다.
      원본 타입의 추가 선택적 매개 변수는 오류가 아니며 원본 타입의 해당 매개 변수가 없는 대상 타입의 선택적 매개 변수는 오류가 아닙니다.
      
-
      함수에 나머지 매개 변수가 있으면 함수가 선택적 매개 변수의 무한적입 집합인것처럼 처리됩니다.
      
-
      이는 타입 시스템의 관점에서 보면 중요하지 않지만 런타임 관점에서 선택적 매개 변수의 개념은 일반적으로 잘 적용되지 않습니다.
      왜냐하면 그 위치에서 undefined가 통과하는 것이 대부분의 함수가 같기 때문입니다.
      
-
      동기를 부여하는 예제는 콜백을 수행하고 일부(개발자에게) 예측 가능하지만 (타입 시스템에) 알 수 없는 인수를 사용하여 호출하는 함수의 일반적인 패턴입니다.
      
+
      컴파일러 플래그인 strictFunctionTypes을 통해 이러한 상황이 발생하면 TypeScript에서 오류가 발생하도록 할 수 있습니다.
      
+
      선택적 매개변수와 나머지 매개변수 (Optional Parameters and Rest Parameters)
      
+
      함수의 호환성을 비교할 때 선택적 매개변수와 필수 매개변수를 서로 바꿔 사용할 수 있습니다.
+원본 타입의 추가 선택적 매개변수는 오류가 아니고, 원본 타입의 해당 매개변수가 없는 대상 타입의 선택적 매개변수도 오류가 아닙니다.
      
+
      함수가 나머지 매개변수를 가지고 있다면, 마치 무한한 일련의 선택적 매개변수처럼 처리됩니다.
      
+
      이것은 타입 시스템 관점에서는 바람직하지 않지만, 런타임 관점에서는 해당 위치에 undefined를 전달하는 것은 대부분 함수에 해당하므로 선택적 매개변수에 대한 아이디어는 제대로 적용되지 않습니다.
      
+
      다음을 유발하는 예제는 콜백을 받아서 (프로그래머에게는) 예측이 가능하지만 (타입 시스템이) 알 수 없는 개수의 인수를 호출하는 함수의 일반적인 패턴입니다:
      
 
      function invokeLater(args: any[], callback: (...args: any[]) => void) {
-    /* ... 'arg'로 콜백을 호출합니다. ... */
+    /* ... 'args'를 사용하여 콜백을 호출함 ... */
 }
 
-// 부적절함 - invokeLater 임의의 수의 인수를 제공"할 수도 있습니다"
+// 바람직하지 않음 - invokeLater는 "아마도" 여러개의 인수를 제공합니다
 invokeLater([1, 2], (x, y) => console.log(x + ", " + y));
 
-// 혼란스러움 (x와 y는 정말로 필요합니다) 발견 할 수 없습니다.
+// 혼란스럽고 (x와 y가 실제로 필요함) 발견할 수 없음
 invokeLater([1, 2], (x?, y?) => console.log(x + ", " + y));
 
      
 
      오버로드 함수 (Functions with overloads)
      
-
      함수에 오버로드가 있는 경우 원본 타입의 각 오버로드는 대상 타입의 호환가능한 시그니처과 일치해야합니다.
      이렇게하면 원본 함수와 동일한 모든 상황에서 대상 함수를 호출 할 수 있습니다.
      
+
      함수에 오버로드가 있는 경우 원본 타입의 각 오버로드는 대상 타입의 호환 가능한 시그니처와 일치해야 합니다.
+이를 통해 원본 함수와 모든 동일한 상황에서 대상 함수를 호출할 수 있습니다.
      
 
      열거형 (Enums)
      
-
      열거형은 숫자와 호환되며 숫자는 열거형과 호환됩니다.
      다른 열거형에서 가져온 열거형의 값은 호환되지 않는 것으로 간주됩니다.
      
-
      예를 들어
      
+
      열거형은 숫자와 호환되며 숫자는 열거형과 호환됩니다. 다른 열거형 타입의 열거형 값은 호환되지 않는 것으로 간주됩니다. 예를 들면,
      
 
      enum Status { Ready, Waiting };
 enum Color { Red, Blue, Green };
 
@@ -839,8 +888,9 @@ 
      열거형 (Enums)
      
 status = Color.Green;  // 오류
 
      
 
      클래스 (Classes)
      
-
      클래스는 한가지 예외를 제외하고 객체의 리터럴 타입 및 인터페이스와 유사하게 작동합니다: 정적 타입과 인스턴스 타입을 모두 포함합니다.  
      
-
      한 클래스 타입의 두 객체를 비교할 때 인스턴스의 멤버만 비교됩니다.
      정적 멤버 및 생성자는 호환성에 영향을 미치지 않습니다.
      
+
      클래스는 객체 리터럴 타입과 인터페이스와 한 가지 예외를 제외하곤 유사하게 동작합니다: 클래스는 정적 타입과 인스턴스 타입이 있습니다.
+클래스 타입의 두 개의 객체를 비교할 때, 오직 인스턴스의 멤버만 비교됩니다.
+정적인 멤버와 생성자는 호환성에 영향을 주지 않습니다.
      
 
      class Animal {
     feet: number;
     constructor(name: string, numFeet: number) { }
@@ -854,34 +904,37 @@ 
      클래스 (Classes)
      let a: Animal;
 let s: Size;
 
-a = s;  // 좋아요
-s = a;  // 좋아요
+a = s;  // 성공
+s = a;  // 성공
 
      
-
      클래스의 Private와 protected 멤버 (Private and protected members in classes)
      
-
      클래스의 Private와 및 protected 멤버는 호환성에 영향을 줍니다.
      클래스의 인스턴스가 호환성을 검사할 때 대상 타입에 private 멤버가 포함되어 있으면 원본 타입에 동일한 클래스에서 비롯된 private 멤버가 포함되어 있어야합니다.
      마찬가지로 protected 멤버가 있는 인스턴스에도 동일하게 적용됩니다.
      이를 통해 클래스는 수퍼 클래스와 할당을 지정하는 것이 가능하지만 다른 상속 계층 구조의 클래스에서는 동일한 형태을 가질 수 없습니다.
      
+
      클래스의 private 멤버와 protected 멤버 (Private and protected members in classes)
      
+
      클래스의 private과 protected 멤버는 호환성에 영향을 줍니다.
+클래스 인스턴스의 호환성을 검사할 때 대상 타입에 private 멤버가 있다면, 원본 타입 또한 동일 클래스에서 비롯된 private 멤버가 있어야 합니다.
+마찬가지로 protected 멤버가 있는 인스턴스도 똑같이 적용됩니다.
+이를 통해 클래스는 상위 클래스와 호환 가능하지만 같은 형태를 가진 다른 상속 계층 구조의 클래스와는 호환이 되지 않습니다.
      
 
      제네릭 (Generics)
      
-
      TypeScript는 구조적인 타입 시스템이기 때문에 타입 매개변수는 멤버 타입의 일부로 사용될 때 결과 타입에 만 영향을 줍니다.
      
-
      예를 들어
      
+
      TypeScript는 구조적 타입 시스템이기 때문에, 타입 매개변수는 멤버의 타입의 일부로 사용할 때 결과 타입에만 영향을 줍니다. 에를 들면,
      
 
      interface Empty<T> {
 }
 let x: Empty<number>;
 let y: Empty<string>;
 
-x = y;  // 좋아요, y는 x의 구조와 일치합니다
+x = y;  // 성공, y는 x의 구조와 대응하기 때문
 
      
-
      위의 경우 x와 y의 구조가 인수 타입를 차별화된 방식으로 사용하지 않기 때문에 호환 가능합니다.
      
-
      Empty<T>에 멤버를 추가하여 이 예제를 변경하면 어떻게 동작하는지 보여줍니다 :
      
+
      위에서 x와 y는 구조가 타입 인수를 서로 다르게 사용하지 않기 때문에 호환됩니다.
+이 예제에 Empty<T>를 멤버에 추가하여 어떻게 동작하는 살펴봅시다:
      
 
      interface NotEmpty<T> {
     data: T;
 }
 let x: NotEmpty<number>;
 let y: NotEmpty<string>;
 
-x = y;  // 오류, x와 y는 호환되지 않습니다
+x = y;  // 오류, x와 y 는 호환되지 않음
 
      
-
      이런 식으로 인수 타입이 명시된 제네릭 타입은 비-제네릭 타입처럼 동작합니다.
      
-
      인수 타입 지정되지 않은 제네릭 타입의 경우 모든 지정되지 않은 인수 타입 대신에 any를 지정하여 호환성을 검사합니다.
      그런 다음 결과로 나타나는 유형의 호환성을 일반적이지 않은 경우와 마찬가지로 검사합니다.
      그 결과 생성된 타입은 비-제네릭 경우와 마찬가지로 호환성을 검사합니다.
      
-
      예를 들어
      
+
      이런 식으로, 타입 인수가 지정된 제네릭 타입은 비-제네릭 타입처럼 동작합니다.
      
+
      타입 인수가 지정되지 않은 제네릭 타입에 관해선, 모든 지정되지 않은 타입 인수를 대신해서 any로 지정함으로써 호환성 검사를 합니다.
+그 결과 생성된 타입은 비-제네릭 경우와 마찬가지로 호환성을 검사합니다.
      
+
      예를 들어,
      
 
      let identity = function<T>(x: T): T {
     // ...
 }
@@ -890,14 +943,16 @@ 
      제네릭 (Generics)// ...
 }
 
-identity = reverse;  // 좋아요 왜냐하면 (x: any)=>any 일치 (y: any)=>any
+identity = reverse;  // 성공, (x: any) => any는  (y: any) => any와 대응하기 때문
 
      
 
      고급 주제 (Advanced Topics)
      
 
      하위 타입 vs 할당 (Subtype vs Assignment)
      
-
      지금까지는 언어 사양에 정의된 용어가 아닌 '호환성'을 사용했습니다.
      TypeScript에는 두 종류의 호환성이 있습니다: 하위 타입과 할당
      
-
      이러한 할당과 any에서와 숫자 값을 상응하는 열거형까지 할당을 허용하는 규칙과 하위 호환성을 확장에서만 차이가 있다.
      
-
      다른 위치는 상황에 따라 두 가지 호환 메커니즘 중 하나를 사용합니다.
      실용적인 목적을 위해 타입 호환성은 implements와 extends의 경우에도 할당 호환성에 의해 결정됩니다.
      
-
      자세한 내용은 TypeScript 사양을 참조하십시오.
      
+
      지금까지 언어 사양에 정의된 용어가 아닌 "호환" 을 사용했습니다.
+TypeScript에서는 두 가지 종류의 호환성이 있습니다: 하위 타입과 할당.
+할당은 하위 타입의 호환성을 확장하여 any에서의 할당과 enum과 해당 숫자 값의 할당을 허용하는 규칙을 가진다는 점만 다릅니다.
      
+
      언어에서 다른 위치는 상황에 따라 두 가지 호환 메커니즘 중 하나를 사용합니다.
+실용적인 목적을 위해 타입 호환성은 심지어 implements와 extends의 경우에도 할당 호환성에 의해 결정됩니다.
      
+
      자세한 내용은 TypeScript 사양을 참고하세요.
      
 
                                 
                                 
      
@@ -941,7 +996,7 @@ 
      No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"타입 호환성","level":"3.9","depth":1,"next":{"title":"고급 타입","level":"3.10","depth":1,"path":"pages/Advanced Types.md","ref":"pages/Advanced Types.md","articles":[]},"previous":{"title":"타입 추론","level":"3.8","depth":1,"path":"pages/Type Inference.md","ref":"pages/Type Inference.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Type Compatibility.md","mtime":"2019-06-14T05:32:52.249Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"타입 호환성","level":"3.9","depth":1,"next":{"title":"고급 타입","level":"3.10","depth":1,"path":"pages/Advanced Types.md","ref":"pages/Advanced Types.md","articles":[]},"previous":{"title":"타입 추론","level":"3.8","depth":1,"path":"pages/Type Inference.md","ref":"pages/Type Inference.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Type Compatibility.md","mtime":"2020-04-22T15:29:36.179Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Type Inference.html b/pages/Type Inference.html
index 37f79e5a..d1f7d134 100644
--- a/pages/Type Inference.html	
+++ b/pages/Type Inference.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
    • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
      • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
    • 
+        
    • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
      • 
+    
+        
    • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
      • 
     
-        
    • 
+        
    • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
      • 
     
-        
    • 
+        
    • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
    • 릴리즈 노트
      • 
+        
+        
+    
+        
    • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
      • 
+    
+
+    
 
     
    • 
 
@@ -712,49 +758,66 @@ 
      
                                 
      
                                 
                                 
      소개 (Introduction)
      
-
      이 장에서는 TypeScript의 타입 추론(Type Inference)에 대해 설명합니다.
      즉 타입이 어디서 어떻게 추론되는지 논의할 것입니다.
      
-
      기본 (Basics)
      
-
      TypeScript에는 타입을 명시해주지 않았을 때 타입 정보를 제공하기 위해 타입 추론이 사용되는 여러 위치가 있습니다.
      아래 예시 코드를 봅시다.
      
+
      이번 장에서는 TypeScript의 타입 추론을 다루겠습니다. 즉 타입이 어디에서, 어떻게 추론되는지 이야기해보겠습니다.
      
+
      기본 (Basic)
      
+
      TypeScript에서는 타입 표기가 없는 경우 타입 정보를 제공하기 위해 타입을 추론합니다. 예를 들어, 이 코드에서
      
 
      let x = 3;
 
      
-
      x 변수의 타입은 number 라고 추론됩니다.
      이러한 종류의 추론은 변수와 멤버를 초기화하거나 매개 변수의 기본값을 설정하거나 함수 반환 타입을 결정할 때 발생합니다.
      
-
      대부분의 타입 추론은 간단합니다.
      다음 장에서는 타입 추론의 미묘한 차이에 대하여 살펴보겠습니다.
      
-
      가장 일반적인 타입 (Best common type)
      
-
      여러 표현식에서 타입 추론이 이루어지면 그 표현식의 타입이 "가장 일반적인 타입"을 계산하는 데 사용됩니다.
      
-
      예:
      
+
      변수 x 의 타입은 number로 추론됩니다.
+이러한 추론은 변수와 멤버를 초기화하고, 매개변수의 기본값를 설정하며, 함수의 반환 타입을 결정할 때 발생합니다.
      
+
      대부분의 경우에 타입 추론은 직관적입니다.
+타입을 추론하는 방법에 대해 좀 더 자세히 알아보겠습니다.  
      
+
      최적 공통 타입 (Best common type)
      
+
      여러 표현식에서 타입 추론이 발생할 때, 해당 표현식의 타입을 사용하여 "최적 공통 타입"을 계산합니다. 예를 들어,
      
 
      let x = [0, 1, null];
 
      
-
      위의 예제에서 x 의 타입을 추론하기 위해서는 각 배열 요소의 타입을 반드시 고려해야합니다.
      여기서는 배열의 타입에 대한 두가지 선택사항 number 와 null 이 주어집니다.
      가장 일반적인 타입 알고리즘은 각 후보 타입을 고려하고 다른 호부와 호환되는 타입을 선택합니다.
      
-
      제공되는 후보 타입 중에서 가장 일반적인 타입을 선택해야하기 때문에 타입이 공통 구조를 공유하지만 모든 타입의 수퍼 타입(상위 타입)이 하나도 없는 경우도 있습니다.
      
-
      예:
      
+
      위 예제의 x 타입을 추론하려면 각 배열 요소들의 타입을 고려해야 합니다.
+여기서 배열의 타입으로 고를 수 있는 두 가지 후보가 있습니다: number와 null입니다.
+최적 공통 타입 알고리즘은 각 후보 타입을 고려하여 모든 후보 타입을 포함할 수 있는 타입을 선택합니다.
      
+
      후보 타입들로부터 최적 공통 타입을 선택하기 때문에, 모든 후보 타입을 포함할 수 있는 상위 타입이 존재해도 후보 타입 중 상위 타입이 존재하지 않으면 선택할 수 없습니다. 예를 들어:
      
 
      let zoo = [new Rhino(), new Elephant(), new Snake()];
 
      
-
      이상적으로, zoo 배열이 Animal[] 로 추론되기를 원할 수도 있습니다.
      하지만 배열에는 정확히 Animal 타입의 객체가 없기 때문에 배열 요소 타입에 대한 추측을 할 수 없습니다.
      이 문제를 해결하려면 다른 유형의 수퍼 타입이 없는 유형을 명시적으로 제공해야합니다:
      
+
      이상적으로는 zoo 변수가 Animal[] 타입으로 추론되길 원하지만, 배열 중 Animal 타입의 객체가 없기 때문에 Animal을 배열 요소 타입으로 추론하지 않습니다.
+이를 해결하기 위해서는 모든 후보 타입을 포함하는 상위 타입을 표기해야 합니다.
      
 
      let zoo: Animal[] = [new Rhino(), new Elephant(), new Snake()];
 
      
-
      가장 일반적인 타입이 발견되지 않으면 추론의 결과는 유니온 배열(Union Array) 타입인 (Rhino | Elephant | Snake)[] 가 됩니다.
      
-
      상황적 타입 (Contextual Type)
      
-
      타입 추론은 TypeScript의 "다른 방향"에서도 작동합니다.
      이를 "상황적 타이핑(Contextual Typing)" 이라고 합니다.
      상황적 타입은 표현식의 타입의 위치에 의해 암시될 때 발생합니다. 
      
-
      예:
      
+
      최적 공통 타입이 존재하지 않는 경우, 추론의 결과는 (Rhino | Elephant |  Snake)[]과 같은 유니언 배열 타입입니다.
      
+
      문맥상 타이핑 (Contextual Typing)
      
+
      TypeScript에서는 경우에 따라 "다른 방향"에서도 타입을 추론합니다.
+이를 "문맥상 타이핑" 이라고 합니다. 문맥상 타이핑은 표현식의 타입이 해당 위치에 의해 암시될 때 발생합니다. 예를 들면:
      
 
      window.onmousedown = function(mouseEvent) {
-    console.log(mouseEvent.button);  //<- 오류
+    console.log(mouseEvent.button);   //<- 성공
+    console.log(mouseEvent.kangaroo); //<- 오류!
 };
 
      
-
      위의 코드에서 타입 오류를 제공하기 위해 TypeScript 타입 검사기는 Window.onmousedown 함수 타입을 사용하여 오른쪽 함수 표현식의 타입을 추론했습니다.
      이렇게 했을 때 mouseEvent 매개 변수의 타입을 추론할 수 있었습니다.
      이 함수 표현식이 문맥적으로 입력 된 위치에 있지 않으면 mouseEvent 매개변수는 any 타입을 가지며 오류는 발생하지 않습니다.
      
-
      문맥적으로 타입이 정해진 표현식에 명시적인 타입 정보가 포함되어 있면 해당 타입이 무시됩니다.
      
-
      위 예제를 작성했다면:
      
-
      window.onmousedown = function(mouseEvent: any) {
-    console.log(mouseEvent.button);  //<- 이제 오류가 없습니다
+
      여기에서 TypeScript 타입 검사는 Window.onmousedown 함수 타입을 사용하여 할당 오른쪽에 함수 표현식의 타입을 추론합니다.
+이렇게 했을 때 mouseEvent 매개변수의 타입이 button 프로퍼티는 있지만, kangaroo 프로퍼티는 없음을 추론할 수 있습니다.
      
+
      TypeScript는 다른 문맥에서도 타입 추론을 잘해냅니다.
      
+
      window.onscroll = function(uiEvent) {
+    console.log(uiEvent.button); //<- 오류!
+}
+
      
+
      위 함수가 Window.onscroll에 할당되어 있다는 사실을 기반으로, TypeScript는 uiEvent가 이전 예제의 MouseEvent가 아닌 UIEvent 임을 알고 있습니다. UIEvent 객체에는 button 프로퍼티가 없어서 TypeScript가 오류를 발생시킵니다.
      
+
      만약 이 함수가 문맥적으로 타입이 추론되지 않는 위치에 있다면, 함수의 인수는 암묵적으로 any 타입을 가지며 별도의 오류를 보고하지 않습니다. (--noImplicitAny 옵션을 사용하지 않는다면)
      
+
      const handler = function(uiEvent) {
+    console.log(uiEvent.button); //<- 성공
+}
+
      
+
      우리는 함수의 인수 타입을 any 타입 표기하여 재정의할 수 있습니다.
      
+
      window.onscroll = function(uiEvent: any) {
+    console.log(uiEvent.button);  //<- 이제 오류가 발생하지 않음
 };
 
      
-
      매개 변수에 명시적 타입 주석이 있는 함수 표현식은 상황적 타입을 대체합니다.
      일단 그렇게 되면 상황적 타입이 적용되지 않으므로 오류가 발생하지 않습니다.
      
-
      상황적 타이핑은 많은 경우에 적용됩니다.
      일반적인 경우에는 함수 호출에 대한 인수, 할당의 우측 표현식, 타입 단언(Type Assertions), 객체의 멤버와 배열 리터럴, 그리고 반환문입니다.
      상황적 타입은 또한 가장 일반적인 타입의 후보 타입으로도 작용합니다.
      
-
      예:
      
+
      하지만 uiEvent는 button 프로퍼티가 없기 때문에 이 코드는 undefined을 출력합니다.
      
+
      문맥상 타이핑은 많은 경우에 적용됩니다.
+일반적인 경우, 함수 호출 인수, 할당의 오른쪽, 타입 단언, 객체 / 배열 리터럴의 멤버, 반환문이 있습니다.
+문맥상 타입은 최적 공통 타입의 후보 타입으로도 사용됩니다. 예를 들어:
      
 
      function createZoo(): Animal[] {
     return [new Rhino(), new Elephant(), new Snake()];
 }
 
      
-
      이 예에서 가장 일반적인 타입은 Animal, Rhino, Elephant, 그리고 Snake 네가지 집합으로 구성됩니다.
      이 중에서 Animal 은 가장 일반적인 타입 알고리즘으로 선택이 가능합니다.
      
+
      이 예제에서 최적 공통 타입은 4가지 후보 타입을 가집니다: Animal, Rhino, Elephant, and Snake.
+이들 중, Animal이 최적 공통 타입 알고리즘에 의해 선택됩니다.
      
 
                                 
                                 
      
@@ -798,7 +861,7 @@ 
      No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"타입 추론","level":"3.8","depth":1,"next":{"title":"타입 호환성","level":"3.9","depth":1,"path":"pages/Type Compatibility.md","ref":"pages/Type Compatibility.md","articles":[]},"previous":{"title":"열거형","level":"3.7","depth":1,"path":"pages/Enums.md","ref":"pages/Enums.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Type Inference.md","mtime":"2019-06-14T05:32:52.250Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"타입 추론","level":"3.8","depth":1,"next":{"title":"타입 호환성","level":"3.9","depth":1,"path":"pages/Type Compatibility.md","ref":"pages/Type Compatibility.md","articles":[]},"previous":{"title":"열거형","level":"3.7","depth":1,"path":"pages/Enums.md","ref":"pages/Enums.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Type Inference.md","mtime":"2020-04-22T15:29:36.179Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/Utility Types.html b/pages/Utility Types.html
new file mode 100644
index 00000000..df5cc06d
--- /dev/null
+++ b/pages/Utility Types.html	
@@ -0,0 +1,1087 @@
+
+
+
+    
+        
+        
+        유틸리티 타입 · GitBook
+        
+        
+				
+				
+        
+        
+        
+        
+        
+    
+    
+    
+
+    
+            
+                
+                
+                
+            
+                
+                
+                
+            
+                
+                
+                
+            
+                
+                
+                
+            
+                
+                
+                
+            
+        
+
+    
+
+    
+        
+    
+        
+    
+        
+    
+        
+    
+        
+    
+        
+    
+
+    
+    
+    
+
+        
+    
+    
+    
+    
+    
+    
+    
+    
+
+    
+    
+    
+    
+    
+    
+
+    
+    
+        
+
      
+    
      
+        
+            
+
+
+            
+                
+            
+        
+    
      
+
+    
      
+        
+            
      
+                
+                    
+
+
+
+
+
+
+                    
      
+                        
      
+                            
+
      
+    
      
+    
+                                
      
+                                
+                                
      소개 (Introduction)
      
+
      TypeScript는 공통 타입 변환을 용이하게 하기 위해 몇 가지 유틸리티 타입을 제공합니다. 이런 유틸리티들은 전역으로 사용 가능합니다.
      
+
      목차 (Table of contents)
      
+
+
      Partial<T>
      
+
      T의 모든 프로퍼티를 선택적으로 만드는 타입을 구성합니다. 이 유틸리티는 주어진 타입의 모든 하위 타입 집합을 나타내는 타입을 반환합니다.
      
+
      예제 (Example)
      
+
      interface Todo {
+    title: string;
+    description: string;
+}
+
+function updateTodo(todo: Todo, fieldsToUpdate: Partial<Todo>) {
+    return { ...todo, ...fieldsToUpdate };
+}
+
+const todo1 = {
+    title: 'organize desk',
+    description: 'clear clutter',
+};
+
+const todo2 = updateTodo(todo1, {
+    description: 'throw out trash',
+});
+
      
+
      Readonly<T>
      
+
      T의 모든 프로퍼티를 읽기 전용(readonly)으로 설정한 타입을 구성합니다, 즉 생성된 타입의 프로퍼티는 재할당할 수 없습니다.
      
+
      예제 (Example)
      
+
      interface Todo {
+    title: string;
+}
+
+const todo: Readonly<Todo> = {
+    title: 'Delete inactive users',
+};
+
+todo.title = 'Hello'; // 오류: 읽기 전용 프로퍼티에 재할당할 수 없음
+
      
+
      이 유틸리티는 런타임에 실패할 할당 표현식을 나타낼 때 유용합니다.(예, frozen 객체의 프로퍼티에 재할당 하려고 하는 경우)
      
+
      Object.freeze
      
+
      function freeze<T>(obj: T): Readonly<T>;
+
      
+
      Record<K,T>
      
+
      타입 T의 프로퍼티의 집합 K로 타입을 구성합니다. 이 유틸리티는 타입의 프로퍼티들을 다른 타입에 매핑시키는 데 사용될 수 있습니다.
      
+
      예제 (Example)
      
+
      interface PageInfo {
+    title: string;
+}
+
+type Page = 'home' | 'about' | 'contact';
+
+const x: Record<Page, PageInfo> = {
+    about: { title: 'about' },
+    contact: { title: 'contact' },
+    home: { title: 'home' },
+};
+
      
+
      Pick<T,K>
      
+
      T에서 프로퍼티 K의 집합을 선택해 타입을 구성합니다.
      
+
      예제 (Example)
      
+
      interface Todo {
+    title: string;
+    description: string;
+    completed: boolean;
+}
+
+type TodoPreview = Pick<Todo, 'title' | 'completed'>;
+
+const todo: TodoPreview = {
+    title: 'Clean room',
+    completed: false,
+};
+
      
+
      Omit<T,K>
      
+
      T에서 모든 프로퍼티를 선택한 다음 K를 제거한 타입을 구성합니다.
      
+
      예제 (Example)
      
+
      interface Todo {
+    title: string;
+    description: string;
+    completed: boolean;
+}
+
+type TodoPreview = Omit<Todo, 'description'>;
+
+const todo: TodoPreview = {
+    title: 'Clean room',
+    completed: false,
+};
+
      
+
      Exclude<T,U>
      
+
      T에서 U에 할당할 수 있는 모든 속성을 제외한 타입을 구성합니다.
      
+
      예제 (Example)
      
+
      type T0 = Exclude<"a" | "b" | "c", "a">;  // "b" | "c"
+type T1 = Exclude<"a" | "b" | "c", "a" | "b">;  // "c"
+type T2 = Exclude<string | number | (() => void), Function>;  // string | number
+
      
+
      Extract<T,U>
      
+
      T에서 U에 할당 할 수 있는 모든 속성을 추출하여 타입을 구성합니다.
      
+
      예제 (Example)
      
+
      type T0 = Extract<"a" | "b" | "c", "a" | "f">;  // "a"
+type T1 = Extract<string | number | (() => void), Function>;  // () => void
+
      
+
      NonNullable<T>
      
+
      T에서 null 과 undefined를 제외한 타입을 구성합니다.
      
+
      예제 (Example)
      
+
      type T0 = NonNullable<string | number | undefined>;  // string | number
+type T1 = NonNullable<string[] | null | undefined>;  // string[]
+
      
+
      Parameters<T>
      
+
      함수 타입 T의 매개변수 타입들의 튜플 타입을 구성합니다.
      
+
      예제 (Example)
      
+
      declare function f1(arg: { a: number, b: string }): void
+type T0 = Parameters<() => string>;  // []
+type T1 = Parameters<(s: string) => void>;  // [string]
+type T2 = Parameters<(<T>(arg: T) => T)>;  // [unknown]
+type T4 = Parameters<typeof f1>;  // [{ a: number, b: string }]
+type T5 = Parameters<any>;  // unknown[]
+type T6 = Parameters<never>;  // never
+type T7 = Parameters<string>;  // 오류
+type T8 = Parameters<Function>;  // 오류
+
      
+
      ConstructorParameters<T>
      
+
      ConstructorParameters<T> 타입은 생성자 함수 타입의 모든 매개변수 타입을 추출할 수 있게 해줍니다. 모든 매개변수 타입을 가지는 튜플 타입(T가 함수가 아닌 경우 never)을 생성합니다.
      
+
      예제 (Example)
      
+
      type T0 = ConstructorParameters<ErrorConstructor>;  // [(string | undefined)?]
+type T1 = ConstructorParameters<FunctionConstructor>;  // string[]
+type T2 = ConstructorParameters<RegExpConstructor>;  // [string, (string | undefined)?]
+
      
+
      ReturnType<T>
      
+
      함수 T의 반환 타입으로 구성된 타입을 만듭니다.
      
+
      예제 (Example)
      
+
      declare function f1(): { a: number, b: string }
+type T0 = ReturnType<() => string>;  // string
+type T1 = ReturnType<(s: string) => void>;  // void
+type T2 = ReturnType<(<T>() => T)>;  // {}
+type T3 = ReturnType<(<T extends U, U extends number[]>() => T)>;  // number[]
+type T4 = ReturnType<typeof f1>;  // { a: number, b: string }
+type T5 = ReturnType<any>;  // any
+type T6 = ReturnType<never>;  // any
+type T7 = ReturnType<string>;  // 오류
+type T8 = ReturnType<Function>;  // 오류
+
      
+
      InstanceType<T>
      
+
      생성자 함수 타입 T의 인스턴스 타입으로 구성된 타입을 만듭니다.
      
+
      Example
      
+
      class C {
+    x = 0;
+    y = 0;
+}
+
+type T0 = InstanceType<typeof C>;  // C
+type T1 = InstanceType<any>;  // any
+type T2 = InstanceType<never>;  // any
+type T3 = InstanceType<string>;  // 오류
+type T4 = InstanceType<Function>;  // 오류
+
      
+
      Required<T>
      
+
      T의 모든 프로퍼티가 필수로 설정된 타입을 구성합니다.
      
+
      예제 (Example)
      
+
      interface Props {
+    a?: number;
+    b?: string;
+};
+
+const obj: Props = { a: 5 }; // 성공
+
+const obj2: Required<Props> = { a: 5 }; // 오류: 프로퍼티 'b'가 없습니다
+
      
+
      ThisParameterType
      
+
      함수 타입의 this 매개변수의 타입, 혹은 함수 타입에 this 매개변수가 없을 경우 unknown을 추출합니다.
      
+
      유의: 이 타입은 --strictFunctionTypes가 활성화되었을 때만 올바르게 동작합니다. #32964를 참고하세요.
      
+
      예제 (Example)
      
+
      function toHex(this: Number) {
+    return this.toString(16);
+}
+
+function numberToString(n: ThisParameterType<typeof toHex>) {
+    return toHex.apply(n);
+}
+
      
+
      OmitThisParameter
      
+
      함수 타입에서 'this' 매개변수를 제거합니다.
      
+
      유의: 이 타입은 --strictFunctionTypes가 활성화되었을 때만 올바르게 동작합니다. #32964를 참고하세요.
      
+
      예제 (Example)
      
+
      function toHex(this: Number) {
+    return this.toString(16);
+}
+
+// `bind`의 반환 타입은 이미 `OmitThisParameter`을 사용하고 있습니다, 이는 단지 예제를 위한 것입니다.
+const fiveToHex: OmitThisParameter<typeof toHex> = toHex.bind(5);
+
+console.log(fiveToHex());
+
      
+
      ThisType<T>
      
+
      이 유틸리티는 변형된 타입을 반환하지 않습니다. 대신, 문맥적 this타입에 표시하는 역할을 합니다. 이 유틸리티를 사용하기 위해선 --noImplicitThis 플래그를 사용해야 한다는 것을 유의하세요.
      
+
      예제 (Example)
      
+
      // --noImplicitThis 로 컴파일
+
+type ObjectDescriptor<D, M> = {
+    data?: D;
+    methods?: M & ThisType<D & M>;  // 메서드 안의 'this 타입은 D & M 입니다.
+}
+
+function makeObject<D, M>(desc: ObjectDescriptor<D, M>): D & M {
+    let data: object = desc.data || {};
+    let methods: object = desc.methods || {};
+    return { ...data, ...methods } as D & M;
+}
+
+let obj = makeObject({
+    data: { x: 0, y: 0 },
+    methods: {
+        moveBy(dx: number, dy: number) {
+            this.x += dx;  // 강하게 타입이 정해진 this
+            this.y += dy;  // 강하게 타입이 정해진 this
+        }
+    }
+});
+
+obj.x = 10;
+obj.y = 20;
+obj.moveBy(5, 5);
+
      
+
      위 예제에서, makeObject의 인자로 넘겨지는 methods 객체는 ThisType<D & M>를 포함한 문맥적 타입을 가지고 있고, 따라서 methods 객체의 메서드 안에 this 타입은{ x: number, y: number } & { moveBy(dx: number, dy: number): number }입니다. method 프로퍼티의 타입이 추론의 대상이며 동시에 메서드 안의 this 타입의 출처인 것을 주목하세요.
      
+
      ThisType<T> 마커 인터페이스는 단지 lib.d.ts에 선언된 빈 인터페이스입니다. 객체 리터럴의 문맥적 타입으로 인식되는 것을 넘어, 그 인터페이스는 빈 인터페이스처럼 동작합니다.
      
+
+                                
+                                
      
+                            
+    
      
+    
      
+        
      
+            
+            
       results matching ""
      
+            
        
+            
+        
        
+        
        
+            
+            
        No results matching ""
        
+            
+        
        
+    
        
+
        
+
+                        
        
+                    
        
+                
+            
        
+
+            
+                
+                
+                    
+                
+                
+                
+                
+                    
+                
+                
+            
+        
+    
        
+
+    
+
        
+
+        
+    
+    
+    
+    
+        
+        
+        
+    
+        
+        
+        
+    
+        
+        
+        
+    
+        
+        
+        
+    
+        
+        
+        
+    
+        
+        
+        
+    
+        
+        
+        
+    
+
+    
+
+    
+
diff --git a/pages/Variable Declarations.html b/pages/Variable Declarations.html
index 75f02a44..818148f2 100644
--- a/pages/Variable Declarations.html	
+++ b/pages/Variable Declarations.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
      • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
        • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
      • 
+        
      • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
        • 
+    
+        
      • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
        • 
     
-        
      • 
+        
      • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
        • 
     
-        
      • 
+        
      • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
      • 릴리즈 노트
        • 
+        
+        
+    
+        
      • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
        • 
+    
+
+    
 
     
      • 
 
@@ -711,23 +757,27 @@ 
        
     
                                 
        
                                 
-                                
        소개 (Introduction)
        
-
        let과 const는 JavaScript에서 상대적으로 새로운 두 가지 유형의 변수 선언입니다.
        이전에 언급했듯이 let은 var와 유사하지만 사용자가 JavaScript로 실행하는 일반적인 "결함"을 피할 수 있습니다.
        const는 변수에 재 할당 할 수 없다는 점에서 let의 기능 확장입니다.
        
-
        TypeScript가 JavaScript의 상위 집합이기 때문에 자연스럽게 let과 const를 지원합니다.
        여기서 우리는 이 새로운 선언들에 대해 더 자세히 설명할 것이고 왜 그것들이 var보다 더 바람직한지를 자세히 설명 할 것입니다.
        
-
        만약 JavaScript를 아무렇게나 사용했다면 다음 섹션은 기억을 새롭게 하는 좋은 방법이 될 것입니다.
        JavaScript에서 var 선언의 모든 단점을 잘 알고 있다면 더 쉽게 건너뛸 수 있습니다.
        
-
        var 선언 (var declarations)
        
-
        전통적으로 JavaScript에서 변수 선언은 var 키워드를 사용하였습니다.
        
+                                
        변수 선언 (Variable Declarations)
        
+
        let과 const는 JavaScript에서 비교적 새로운 두 가지 유형의 변수 선언입니다.
+앞에서 언급했듯이, let은 var와 어느 정도 유사하지만, 사용자가 JavaScript에서 자주 마주치는 결함을 피할 수 있게 해줍니다.
+const는 let의 기능이 강화된 것으로 변수에 재할당을 방지합니다.
        
+
        TypeScript는 JavaScript의 상위 집합이므로, 당연히 let과 const를 지원합니다.
+여기서는 새로운 선언 방식들과 왜 그 방식들이 var보다 선호되는지를 더 자세히 설명합니다.
        
+
        JavaScript를 아무렇게나 사용하고 있었다면, 다음 섹션이 기억을 새로 고치도록 도와줄 것입니다.
+JavaScript에서 var 선언의 단점들에 대해 모두 알고 있다면 쉽게 넘어갈 수 있습니다.
        
+
        var 선언 (var declarations)
        
+
        기존 JavaScript에서는 변수 선언을 할 때 var 키워드를 사용했습니다.
        
 
        var a = 10;
 
        
-
        알다시피 방금 a 변수의 값을 10 으로 선언하였습니다.
        
-
        또한 함수 내에서 변수를 선언할 수도 있습니다.
        
+
        알다시피, a라는 변수를 10이라는 값으로 선언했습니다.
        
+
        또한, 변수를 함수 내부에 선언할 수도 있습니다.
        
 
        function f() {
     var message = "Hello, world!";
 
     return message;
 }
 
        
-
        그리고 다른 함수 내부의 동일한 변수에 접근이 가능합니다.
        
+
        그리고, 같은 변수를 다른 함수 안에서 접근할 수도 있습니다.
        
 
        function f() {
     var a = 10;
     return function g() {
@@ -737,11 +787,11 @@ 
        var 선언
 }
 
 var g = f();
-g(); // 오류 '11'
+g(); // '11'을 반환
 
        
-
        위의 예제에서 g함수는 f함수에서 선언된 변수 a를 흭득하였습니다.
        
-
        g함수가 호출되는 시점에 a의 값은 f함수 내에 a의 값에 연결됩니다.
        
-
        f함수가 실행되는 시점에 g함수가 호출되더라도 a에 접근하여 수정할 수 있습니다.
        
+
        위 예제에서, g는 f 안에 선언된 a를 잡아 둡니다.
+언제든 g가 호출될 때, a의 값은 f 안의 a 값을 가리킵니다.
+f가 실행되면서 g가 한번 호출된 후에도, a에 접근해 수정할 수 있습니다.
        
 
        function f() {
     var a = 1;
 
@@ -759,7 +809,8 @@ 
        var 선언
 f(); // '2' 반환
 
        
 
        스코프 규칙 (Scoping rules)
        
-
        var 선언은 다른 언어의 스코프 규칙에 비해 이상한 스코프 규칙이 몇가지 있습니다.
        다음 예를 함께 보겠습니다.
        
+
        var 선언은 다른 언어와 다른 이상한 스코프 규칙들을 가지고 있습니다.
+아래 예제를 살펴보겠습니다:
        
 
        function f(shouldInitialize: boolean) {
     if (shouldInitialize) {
         var x = 10;
@@ -771,8 +822,13 @@ 
        스코
 f(true);  // '10' 반환
 f(false); // 'undefined' 반환
 
        
-
        어떤 독자는 이 예제를 두 번 실행해 볼 수도 있습니다.
        변수 x는 if 블록 내에 선언되어 있지만 블록의 바깥에서 접근할 수 있습니다.
        var 선언은 함수, 모듈, 네임 스페이스 또는 전역 스코프에서 접근할 수 있기 때문에 가능합니다.
        -포함된 블록에 관계없이 나중에 모두 다룰 것입니다.
        이것을 var-scoping 또는 function-scoping이라고 부릅니다.
        매개변수 또한 함수의 스코프입니다.
        
-
        이러한 스코프 규칙은 몇 가지 유형의 실수를 유발할 수 있습니다.
        그들이 악화시키는 한가지 문제점은 동일한 변수를 여러 번 선언하는 것은 실수가 아니라는 사실입니다.
        
+
        이 예제에서, 어떤 분들은 머뭇거릴 수도 있습니다.
+변수 x는 if 블록 안에 선언되어 있지만, 블록의 바깥에서도 이 변수에 접근할 수 있습니다.
+이 이유는 var선언은 이를 감싸고 있는 블록과 관계없이 이를 감싸고 있는 함수, 모듈, 네임스페이스, 전역 스코프에서 접근할 수 있기 때문입니다.
+어떤 이는 이를 var-스코프 혹은 함수 스코프라고 부릅니다.
+매개 변수 또한 함수 스코프입니다.
        
+
        이런 스코프 규칙은 몇 가지 실수를 유발할 수 있습니다.
+더욱 문제를 심각하게 하는 것은 변수를 여러 번 선언하는 것이 에러가 아니라는 것입니다:
        
 
        function sumMatrix(matrix: number[][]) {
     var sum = 0;
     for (var i = 0; i < matrix.length; i++) {
@@ -785,15 +841,16 @@ 
        스코
     return sum;
 }
 
        
-
        어쩌면 다소 쉽게 찾을 수도 있지만 for-loop 내에서 동일한 함수 스코프의 변수를 참조하기 때문에 실수로 변수 i 를 덮어 쓰게 됩니다.
        숙련된 개발자들은 알겠지만 비슷한 종류의 버그는 코드 리뷰에서 끝없는 좌절의 원인이 될 수 있다.
        
+
        아마 쉽게 찾을 수 있겠지만, i가 같은 함수 스코프의 변수를 참조하고 있기 때문에 for-loop 안에서 실수로 변수 i를 덮어쓸 수도 있습니다
+경험 많은 개발자는 바로 알아차리겠지만, 비슷한 종류의 버그는 코드 리뷰를 거치며 좌절의 원인이 되기도 합니다.
        
 
        변수 캡쳐링의 단점 (Variable capturing quirks)
        
-
        잠깐 다음 코드의 출력을 예상을 해보세요
        
+
        다음 코드의 출력 결과를 예상해 보세요:
        
 
        for (var i = 0; i < 10; i++) {
     setTimeout(function() { console.log(i); }, 100 * i);
 }
 
        
-
        익숙하지 않은 사람들을 위해 setTimeout은 일정한 시간이 지나면 함수를 실행하려고 합니다.(실행이 멈추는 것을 기다리고 있습니다.)
        
-
        준비됐나요? 보세요:
        
+
        익숙하지 않은 분들을 위해 말씀드리자면, setTimeout은 특정 밀리 초 후에 함수를 실행합니다.(다른 작업의 실행이 멈추는 것을 기다리며)
        
+
        준비됐나요? 살펴보겠습니다:
        
 
        10
 10
 10
@@ -805,8 +862,8 @@ 
        0
 1
 2
@@ -818,40 +875,48 @@ 
        for (var i = 0; i < 10; i++) {
-    // 현재 값으로 함수를 호출함으로써
-    // 'i'의 현재상태를 캡쳐
+    // 현재 값으로 함수를 호출시켜
+    // 현재 상태의 'i'를 잡아둔다.
     (function(i) {
         setTimeout(function() { console.log(i); }, 100 * i);
     })(i);
 }
 
        
-
        위의 이상하게 생긴 패턴은 매우 일반적입니다.
        매개 변수 목록의 i는 for루프에 선언된 i와 같지만 동일한 네이밍을 했기 때문에 루프를 변경할 필요가 없었습니다.
        
-
        let 선언 (let declarations)
        
-
        이제는 var에 몇 가지 문제가 있다는 것을 알아냈습니다.
        그 이유는 정확히 let이 도입 된 이유입니다.
        let은 var와 동일한 방식으로 작성됩니다.
        
+
        이런 이상해 보이는 패턴이 사실 일반적인 패턴입니다.
+매개변수에 i가 for 루프의 i를 감춰 버립니다. 하지만 이름을 같게 했기 때문에 루프의 실행 부를 크게 수정할 필요가 없습니다.
        
+
        let 선언 (let declarations)
        
+
        이제, var에  몇 가지 문제점에 대해 알게 되었는데, 이런 이유 때문에 let을 도입하게 되었습니다.
+사용되는 키워드를 빼고는 let 문은 var와 동일한 방법으로 작성됩니다.
        
 
        let hello = "Hello!";
 
        
-
        중요한 차이점은 구문에 있는 것이 아니라 의미에 관한 것입니다.
        이제 이 내용을 살펴 보겠습니다.
        
-
        블록-스코프 (Block-scoping)
        
-
        let을 사용하여 변수를 선언할 때 렉시컬-스코프 또는 블록-스코프를 사용합니다.
        스코프가 포함된 함수로 누출되는 var 변수와 달리 블록-스코프 변수는 가장 가깝게 포함된 블록 또는 for 반복문 외부에서 사용할 수 없습니다.
        
+
        주요한 차이점은 구문 보단 의미에 있는데, 이제 이 내용을 살펴볼 것입니다.
        
+
        블록 스코프 (Block-scoping)
        
+
        변수가 let을 이용해 선언되었을 때, 이는 렉시컬 스코핑(lexical-scoping) 혹은 블록 스코핑(block-scoping) 이라 불리는 것을 사용합니다.
+var로 선언된 변수가 이를 포함한 함수까지 흘러나오는 것과 달리, 블록-스코프 변수들은 이를 가장 가깝게 감싸고 있는 블록 혹은 for-루프 밖에서 접근할 수 없습니다.
        
 
        function f(input: boolean) {
     let a = 100;
 
     if (input) {
-        // 'a'는 이곳에서 가능
+        // 'a'를 참조할 수 있습니다.
         let b = a + 1;
         return b;
     }
 
-    // 오류: 'b'는 여기에 존재하지 않습니다.
+    // 오류: 'b'는 여기서 존재하지 않습니다.
     return b;
 }
 
        
-
        여기 두 개의 지역변수 a와 b가 있습니다.
        a의 스코프는 함수 f의 지역변수로 제한되어있고 b의 스코프는 if문 블록에 제한되어있습니다.
        
-
        catch 문안에 선언된 변수에도 유사한 스코프의 스코프 규칙을 갖습니다.
        
+
        여기, 두 지역 변수 a와 b가 있습니다.
+a의 스코프는 f의 블록으로 한정되지만, b는 이를 감싸고 있는 if문의 블록까지로 한정됩니다.
        
+
        catch 문에 선언된 변수 또한 비슷한 스코프 규칙을 가집니다.
        
 
        try {
     throw "oh no!";
 }
@@ -859,29 +924,32 @@ 
        블록
     console.log("Oh well.");
 }
 
-// 오류: 'e'는 여기에 존재하지 않습니다.
+// 오류: 'e'는 여기서 존재하지 않습니다.
 console.log(e);
 
        
-
        블록-스코프 변수의 또 다른 프로퍼티는 실제로 선언되기 전에는 읽거나 쓸 수 없다는 것입니다.
        이러한 변수는 스코프내에서 temporal dead zone 이 될 때까지 "존재"합니다.
        이것은 let 선언 이전에 변수에 먼저 접근 할수 없는 정교한 방법이며 다행스럽게도 TypeScript를 통해 알 수 있습니다.
        
-
        a++; // 'a'를 선언하기전에 사용하는것은 불법입니다;
+
        또 다른 블록-스코프 변수의 특징은 변수들이 선언되기 전에 읽거나, 쓰는 것이 불가능하다는 것입니다.
+이 변수들은 스코프에 걸쳐 "존재"하지만, 선언되는 부분 전까지 모든 부분들이 temploral dead zone입니다.
+이것은 let문 이전에 변수들에 접근할 수 없다는 정교한 방식이며, 다행히 TypeScript가 알려줍니다.
        
+
        a++; // `a`가 선언되기 전에 잘못된 사용.
 let a;
 
        
-
        주의해야 할 점은 블록-스코프 변수가 선언되기 전에 변수를 캡쳐할 수 있다는 것입니다.
        선언전에 해당 함수을 실행시키는 것은 불법이라는 것을 알 수 있습니다.
        
-
        ES2015를 목표로 한다면 현대적인 런타임은 오류를 던질 것입니다.
        그러나 지금은 TypeScripts는 허용되며 오류로 보고하지 않습니다.
        
+
        주의할 점은 여전히 선언되기 전에 블록-스코프 변수를 잡아둘 수 있다는 것입니다.
+선언되기 전에 함수를 실행하는 것이 안된 다는 것만 알아두면 됩니다.
+ES2015를 대상으로한, 최신 런타임은 오류를 던질 것입니다; 하지만 현재 TypeScript에서는 허용되며, 오류를 보고하지 않습니다.
        
 
        function foo() {
-    // 'a'를 캡쳐합니다
+    // 'a' 캡처는 성공
     return a;
 }
 
-// 잘못된 호출로 'foo'가 선언되기 전에 'a'가 선언됩니다.
-// 여기서 런타임 오류가 발생해야합니다.
+// `a`가 선언되기 전에 `foo` 를 호출
+// 런타임에 오류를 던질 것 입니다.
 foo();
 
 let a;
 
        
-
        Temporal dead zone 에 대한 자세한 내용은 Mozilla 개발자 네트워크 의 관련 내용을 참조하십시오.
        
-
        재선언과 Shadowing (Re-declarations and Shadowing)
        
-
        var 를 선언한 횟수가 중요하지 않다고 언급했습니다. 단지 변수를 하나 얻었을 뿐입니다.
        
+
        temporal dead zone에 더 자세한 설명은 Mozilla Developer Network를 살펴보세요.
        
+
        재선언과 쉐도잉 (Re-declarations and Shadowing)
        
+
        var로 선언하면 얼마나 변수를 많이 선언하는지는 중요하지 않다고 했습니다. 단 하나만 생성됩니다.
        
 
        function f(x) {
     var x;
     var x;
@@ -891,21 +959,24 @@ 
        let x = 10;
-let x = 20; // 오류: 동일한 스코프에서 'x'를 다시 선언 할 수 없습니다.
+let x = 20; // 오류: 'x'를 같은 스코프에 선언할 수 없습니다.
 
        
-
        TypeScript의 블록-스코프는 두개의 같은 변수는 필요하지 않다고 우리에게 문제를 말해줍니다.
        
+
        TypeScript가 문제를 알려주기 때문에, 변수를 반드시 블록 범위로 지정할 필요는 없습니다.
        
 
        function f(x) {
-    let x = 100; // 오류: 매개변수가 변수 선언에 간섭하고 있습니다.
+    let x = 100; // 오류: 매개 변수 선언을 방해합니다.
 }
 
 function g() {
     let x = 100;
-    var x = 100; // 오류: 'x'의 선언을 두 번 할 수 없습니다.
+    var x = 100; // 오류: `x`를 중복해서 선언할 수 없습니다.
 }
 
        
-
        블록-스코프 변수가 함수-스코프 변수로 선언될 수 없다는 뜻은 아닙니다.
        블록-스코프 변수는 명확하게 다른 블록 내에서 선언되어야합니다.
        
+
        블록-스코프 변수가 함수-스코프 변수로 선언될 수 없다는 것은 아닙니다.
+블록 스코프 변수는 단지 별개의 다른 블록에 선언되어야 합니다.
        
 
        function f(condition, x) {
     if (condition) {
         let x = 100;
@@ -918,8 +989,9 @@ 
        f(false, 0); // '0' 반환
 f(true, 0);  // '100' 반환
 
        
-
        중첩된 스코프에서 기존의 변수 이름을 사용하는 것을 shadowing 이라고 합니다.
         shadowing 은 우발적인 버그를 유발하는 동시에 버그를 예방할 수도 있다는 점에서 양날의 검입니다.
        
-
        예를 들어 let 변수를 사용하여 이전 sumMatrix 함수를 작성했다고 가정해 보겠습니다.
        
+
        더 중첩된 스코프에서 바깥 스코프의 변수 이름을 사용하는 것을 shadowing이라고 합니다.
+shadowing은 양날의 검이라고 할 수 있는데, 이는 실수로 방생되어 특정 버그를 일으키거나, 혹은 특정 버그를 막기 위해 쓰이기 때문입니다.
+예를 들어, 위에서 사용했던 sumMatrix 함수를 let 을 이용해서 작성했다고 생각해 봅시다.
        
 
        function sumMatrix(matrix: number[][]) {
     let sum = 0;
     for (let i = 0; i < matrix.length; i++) {
@@ -932,10 +1004,13 @@ 
        return sum;
 }
 
        
-
        이번 버전의 루프는 내부의 반복문의 i가 외부의 반복문의 i를 shadows하기때문에 실제로 계산을 합니다.
        
-
        Shadowing은 보통 더 명확한 코드를 작성하기 위해 피해야 합니다.
        이를 활용할 수 있는 몇 가지 시나리오가 있을 수 있지만 최선의 판단을 내려야 합니다.
        
-
        블럭-스코프 변수 캡쳐
        
-
        var 선언으로 변수 캡쳐를 처음 접했을 때 우리는 일단 캡쳐된 변수가 어떻게 작동하는지 간략하게 살펴보았습니다.
        이것에 대한 직감적이고 더 나은 직감을 주기 위해 스코프가 실행될 때마다 변수의 "환경"을 생성합니다.
        해당 환경 및 캡쳐 된 변수는 스코프 내의 모든 항목이 완료된 후에도 존재할 수 있습니다
        
+
        이 루프는 합을 올바르게 계산할 것입니다. 왜냐하면 안쪽 루프의 i 가 바깥 루프의 i를 가리기 때문입니다.
        
+
        보통 더 명확한 코드 작성을 위해 shadowing 사용을 피합니다.
+하지만 shadowing의 이점을 활용할 수 있는 적합한 상황이 있으므로, 최선의 판단을 내려야 합니다.
        
+
        블록 스코프 변수 캡쳐링 (Block-scoped variable capturing)
        
+
        var 선언에 변수 캡쳐링을 하는 것을 처음 보았을 때, 변수가 한번 캡쳐되면 어떻게 동작하는지 간단히 살펴보았습니다.
+이를 더 잘 이해해 보면, 스코프가 각각 실행될 때마다 변수의 "환경"을 만듭니다.
+변수의 환경과 캡쳐된 변수들은 심지어 스코프가 포함한 모든 것이 실행을 종료한 후에도 존재합니다.
        
 
        function theCityThatAlwaysSleeps() {
     let getCity;
 
@@ -949,14 +1024,18 @@ 
        return getCity();
 }
 
        
-
        환경내에서 city를 캡쳐했으므로 if 블록이 실행을 완료 했음에도 불구하고 여전히 접근할 수 있습니다.
        
-
        이전의 setTimeout 예제에서 for 문을 반복할 때마다 변수의 상태를 캡쳐하기 위해 IIFE를 사용해야한다는 결론을 얻었습니다.
        실제로 하고 있던 것은 캡쳐한 변수를 위한 새로운 변수 환경을 만드는 것이었습니다.
        그것은 약간의 고통이었지만 다행스럽게도 TypeScript에서 그렇게 할 필요가 없습니다.
        
-
        let은 루프의 일부로 선언될 때 크게 다른 동작을 합니다.
        루프 자체에 새로운 환경을 도입하기보다는 이러한 선언은 반복마다 새로운 스코프를 만듭니다.
        이것이 IIFE로 하고 있었던 것을 let 을 사용하여 이전의 setTimeout 예제를 바꿀 수 있습니다.
        
+
        city를 해당 환경 안에 캡쳐했기 때문에, if 블록의 실행이 완료되었음에도 여전히 city에 접근할 수 있습니다.
        
+
        앞의 setTimeout 예제에서, for 루프가 매번 반복될 때마다 변수를 캡쳐하기 위해서 IIFE를 사용했던 것을 떠올려 봅시다.
+실제론, 캡처된 변수를 위해 새로운 변수 환경을 만드는 것이었습니다.
+이는 약간의 고통스러운 일이지만, 다행히, 타입스크립트 에서는 그렇게 할필요가 없습니다.
        
+
        let 선언은 루프의 일부로 선언될 때 동작이 크게 다릅니다.
+이 선언은 루프 자체에 새로운 환경을 만드는 대신, 반복마다 새로운 환경을 만들어 냅니다.
+어쨋든 이건 IIFE를 통해 하고 있었던 동작이므로, 이전 setTimeout예제를 let선언만 사용해서 바꿀수 있습니다.
        
 
        for (let i = 0; i < 10 ; i++) {
     setTimeout(function() { console.log(i); }, 100 * i);
 }
 
        
-
        예상한대로 출력됩니다.
        
+
        그리고 예상 했던 대로, 다음과 같은 결과가 출력됩니다.
        
 
        0
 1
 2
@@ -968,12 +1047,13 @@ 
        const 선언 (const declarations)
        
-
        const 는 변수를 선언하는 또 다른 방법입니다.
        
+
        const 선언 (const declarations)
        
+
        const 선언은 변수를 선언하는 또 다른 방법입니다.
        
 
        const numLivesForCat = 9;
 
        
-
        그것은 let 선언과 같지만 그 이름에서 알 수 있듯이 바인딩 된 후에는 값을 변경할 수 없습니다.
        즉 let과 동일한 스코프 규칙을 가지고 있지만 규칙을 다시 할당할 수 없습니다.
        
-
        이것은 참조하는 값이 불변 이라는 개념과 혼동되어서는 안됩니다.
        
+
        이 방법은 let 선언과 비슷하지만 그 이름에서 말해주듯이, 일단 바인딩 되면 값을 변경할 수 없습니다.
+다른 말로 const는 let과 같은 스코프 규칙을 가지고 있지만, 재할당 할 수 없습니다.
        
+
        이를 const가 참조하는 값이 불변이라고 혼동하면 안 됩니다.
        
 
        const numLivesForCat = 9;
 const kitty = {
     name: "Aurora",
@@ -986,59 +1066,83 @@ 
        const 선&#
     numLives: numLivesForCat
 };
 
-// 모두 "좋아요"
+// 모두 "성공"
 kitty.name = "Rory";
 kitty.name = "Kitty";
 kitty.name = "Cat";
 kitty.numLives--;
 
        
-
        이를 방지하기 위해 구체적인 조치를 취하지 않는 한 const변수의 내부 상태는 여전히 수정할 수 있습니다. 다행히 TypeScript를 사용하면 객체의 멤버를 readonly로 지정할 수 있습니다.
        
-
        Interfaces 챕터에서 자세한 내용을 다룹니다.
        
+
        위와 같은 상황을 피하기 위해 특별한 조치를 취하지 않는 한, const 변수의 내부 상태는 여전히 수정 가능합니다.
+다행히, TypeScript를 사용하면 객체의 멤버가 읽기 전용(readonly)이라고 지정할 수 있습니다.
+Interfaces 챕터에 자세히 설명되어 있습니다.
        
 
        let vs. const
        
-
        비슷한 스코프 지정 의미론을 가진 두 가지 선언이 있다고 가정할 때 어떤 것을 사용할 것인지를 묻는 것은 당연합니다.
        대부분의 질문들과 같이 그 대답도 다음과 같습니다: 그것은 다릅니다.
        
-
        principle of least privilege (최소 권한 원칙) 적용하면 수정할 권한을 제외한 모든 선언은 'const'를 사용해야 합니다.
        
-
        근본적인 이유는 변수를 쓸 필요가 없는 경우 동일한 코드 베이스에서 작업하는 다른 사용자가 자동으로 객체에 쓸 수 없으므로 변수에 재할당 할 필요가 있는지 여부를 고려해야 합니다.
        
-
        또한 const를 사용하면 데이터 흐름을 추론할 때 코드를 더 예측 가능하게 만들 수 있습니다.
        최선을 판단을 하여 해당되는 경우 팀원들과 이 문제를 상의하십시오.
        
-
        이 handbook 의 경우 대부분 let 선언을 사용합니다.
        
-
        비구조화 (Destructuring)
        
-
        TypeScript에 있는 또 다른 ECMAScript2015 기능은 비구조화입니다.
        전체 참조 정보는 Mozilla Developer Network의 기사를 참조하세요.
        이 섹션에서는 간단한 개요를 제공합니다.
        
-
        배열 비구조화 (Array destructuring)
        
-
        가장 간단한 구조 해체 방법은 배열 비구조화 할당입니다.
        
+
        유사한 스코프의 의미를 가지는 두 가지 유형의 변수 선언이 있기 때문에, 어느 것을 사용하는지는 스스로 선택해야 합니다.
+광범위한 질문처럼, 답은 '때에 따라 다르다'입니다.
        
+
        최소 권한의 원칙을 적용하면, 수정하려는 선언 이외에 모든 선언은 const를 사용해야 합니다.
+그 이유는, 만약 변수가 수정될 필요가 없다면 같은 코드베이스에서 작업하는 다른 사람들이 자동으로 객체를 수정할 수 없어야 하고, 그들이 정말 변수에 재할당할 필요가 있는지 고려할 필요가 있습니다.
+const를 사용하는 것은 데이터의 흐름을 추론할 때 코드를 더 예측하기 쉽게 해줍니다.
        
+
        최선의 판단을 하고 해당되는 경우, 팀원들과 문제에 대해 상의하세요.
        
+
        이 핸드북은 대부분 let 선언을 사용합니다.
        
+
        구조 분해 (Destructuring)
        
+
        TypeScript가 가진 또 다른 ECMAScript 2015 특징은 구조 분해입니다.
+자세한 내용은, Mozilla Developer Network의 글을 참고 하세요.
+이번 섹션에서는 간단하게 개요를 살펴보겠습니다.
        
+
        배열 구조 분해 (Array destructuring)
        
+
        구조 분해의 가장 단순한 형태는 배열 구조 분해 할당입니다:
        
 
        let input = [1, 2];
 let [first, second] = input;
 console.log(first); // 1 출력
 console.log(second); // 2 출력
 
        
-
        이것은 first와 second라는 두 개의 새로운 변수를 만듭니다.
        
-
        이는 인덱스를 사용하는 것과 동일하지만 훨씬 편리합니다.
        
+
        이는 first, second라는 이름의 새로운 두 변수를 생성합니다.
+이는 인덱싱을 사용하는 것과 동일하지만 더 편리합니다:
        
 
        first = input[0];
 second = input[1];
 
        
-
        비구조화는 이미 선언된 변수에서도 작동합니다.
        
-
        // 변수 교환
+
        구조 분해 할당은 이미 선언된 변수에도 동작합니다:
        
+
        // 변수를 스왑
 [first, second] = [second, first];
 
        
-
        함수에 대한 매개 변수가 있는 경우
        
+
        그리고, 함수의 매개변수에도 동작합니다:
        
 
        function f([first, second]: [number, number]) {
     console.log(first);
     console.log(second);
 }
 f([1, 2]);
 
        
-
        ... 구문을 사용하여 목록의 나머지 항목에 대한 변수를 생성할 수 있습니다.
        
+
        나머지 요소들에 대해 ... 구문을 사용하여 변수를 생성할 수 있습니다:
        
 
        let [first, ...rest] = [1, 2, 3, 4];
 console.log(first); // 1 출력
 console.log(rest); // [ 2, 3, 4 ] 출력
 
        
-
        물론 이것은 JavaScript이므로 관심이 없는 후행 요소는 무시할 수 있습니다.
        
+
        물론 JavaScript이기 때문에, 필요하지 않은 뒤따라 오는 요소들을 무시할 수 있습니다:
        
 
        let [first] = [1, 2, 3, 4];
 console.log(first); // 1 출력
 
        
-
        또는 다른 요소들 :
        
+
        또는 그 밖에 요소들을 무시할 수 있습니다:
        
 
        let [, second, , fourth] = [1, 2, 3, 4];
+console.log(second); // 2 출력
+console.log(fourth); // 4 출력
+
        
+
        튜플 구조 분해 (Tuple destructuring)
        
+
        튜플은 배열처럼 구조 분해됩니다; 구조 분해된 변수는 튜플 요소와 일치하는 타입을 얻게 됩니다:
        
+
        let tuple: [number, string, boolean] = [7, "hello", true];
+
+let [a, b, c] = tuple; // a: number, b: string, c: boolean
+
        
+
        튜플의 범위를 넘어선 구조 분해는 오류입니다:
        
+
        let [a, b, c, d] = tuple; // 오류, 인덱스 3에 요소가 없습니다.
+
        
+
        배열과 마찬가지로, 더 짧은 튜플을 얻기 위해 ...로 튜플의 나머지를 구조 분해할 수 있습니다.
        
+
        let [a, ...bc] = tuple; // bc: [string, boolean]
+let [a, b, c, ...d] = tuple; // d: [], 비어있는 튜플
+
        
+
        또는 뒤따라 오는 요소나 다른 요소를 무시할 수 있습니다:
        
+
        let [a] = tuple; // a: number
+let [, b] = tuple; // b: string
 
        
-
        객체 비구조화 (Object destructuring)
        
-
        또한 객체를 해체할 수 있습니다.
        
+
        객체 구조 분해 (Object destructuring)
        
+
        또한 객체를 구조 분해할 수 있습니다:
        
 
        let o = {
     a: "foo",
     b: 12,
@@ -1046,82 +1150,99 @@ 
        
 };
 let { a, b } = o;
 
        
-
        이것은 o.a와 o.b에서 새로운 변수 a와 b를 생성합니다. 필요없는 경우 c를 건너뛸 수 있습니다.
        
-
        배열 비구조화처럼 선언없이 할당 수 있습니다.
        
+
        이는 o.a, o.b로 부터 새로운 변수 a와 b를 생성합니다.
+필요 없다면 c를 건너 뛸 수 있다는 걸 알아두세요.
        
+
        배열 구조 분해처럼, 선언 없이 할당할 수 있습니다.:
        
 
        ({ a, b } = { a: "baz", b: 101 });
 
        
-
        이 문장을 괄호로 묶어야한다는 것을 주목하십시오.
        JavaScript는 일반적으로 a{를 블록 시작으로 파싱합니다.
        
-
        ... 구문을 사용하여 객체의 나머지 항목에 대한 변수를 만들 수 있습니다
        
+
        이 구문을 괄호로 감싸고 있다는 것을 주의해 주세요.
+JavaScript는 보통 {를 블록의 시작으로 파싱 합니다.
        
+
        객체 안에 나머지 요소들을 ... 구문을 사용하여 변수로 생성할 수 있습니다:
        
 
        let { a, ...passthrough } = o;
 let total = passthrough.b + passthrough.c.length;
 
        
-
        프로퍼티 이름 변경 (Property renaming)
        
-
        프로퍼티의 이름 또한 다름 이름으로 지정할 수 있습니다.
        
+
        프로퍼티 이름 바꾸기 (Property renaming)
        
+
        프로퍼티들에 다른 이름을 붙히는 것도 가능합니다.
        
 
        let { a: newName1, b: newName2 } = o;
 
        
-
        문장이 혼란스러워지기 시작했습니다.
        
-
        a : newName1를 "a as newName1"로 읽을 수 있습니다.
        
-
        방향은 왼쪽에서 오른쪽으로 사용합니다.
        
+
        여기서 구문이 혼란스러워지기 시작합니다.
+a: newName1 을 "a를 newName1 로" 와 같이 읽을 수 있습니다.
+여태 써왔던 것 처럼 방향은 왼쪽에서 오른쪽입니다:
        
 
        let newName1 = o.a;
 let newName2 = o.b;
 
        
-
        혼란스럽겠지만 여기서 콜론은 타입을 나타내는 콜론은 아닙니다.
        형식을 지정하는 경우 전체 형식이 비구조화된 후에도 형식을 작성해야 합니다.
        
+
        혼란스럽게도 여기서 콜론은 타입을 나타내지 않습니다.
+타입을 지정하는 경우, 전체 구조 분해 뒤에 작성해야 합니다:
        
 
        let { a, b }: { a: string, b: number } = o;
 
        
-
        기본값 (Default values)
        
-
        기본값을 사용하면 프로퍼티가 정의되지 않은 경우의 기본값을 지정할 수 있습니다.
        
+
        기본 값 (Default values)
        
+
        기본 값은 프로퍼티가 정의되지 않았을 때 기본값을 사용하도록 하는 것입니다:
        
 
        function keepWholeObject(wholeObject: { a: string, b?: number }) {
     let { a, b = 1001 } = wholeObject;
 }
 
        
-
        keepWholeObject 함수는 b가 정의되지 않더라도 a와 b 프로퍼티뿐만 아니라 wholeObject의 변수를 가집니다.
        
+
        예제에서 b?는 b가 선택적이라는 것을 의미합니다. 따라서 이는 undefined 일 수도 있습니다.
+keepWholeObject는 이제 b가 undefined 이더라도 a, b 프로퍼티와 함께 wholeObject라는 변수를 가집니다.
        
 
        함수 선언 (Function declarations)
        
-
        비구조화는 함수 선언에서도 작동합니다.
        간단한 예를 보겠습니다.
        
+
        구조 분해는 함수 선언에서도 동작합니다.
+이것은 간단한 경우에는 직관적입니다:
        
 
        type C = { a: string, b?: number }
 function f({ a, b }: C): void {
     // ...
 }
 
        
-
        그러나 매개 변수에 대해 기본값을 지정하는 것이 더 일반적이며 비구조화시 기본값을 가져오는 것은 까다로울 수 있습니다.
        
-
        우선 기본값 앞에 패턴을 두는 것을 기억해야 합니다.
        
-
        function f({ a, b } = { a: "", b: 0 }): void {
+
        그러나 매개 변수에는 기본값을 명시하는 것이 더 일반적이며, 구조 분해와 함께 기본값을 제대로 사용하는 것은 까다로울 수 있습니다.
+가장 먼저, 구조 분해 패턴을 기본값 앞에 넣어야 한다는 것을 기억해야 합니다.
        
+
        function f({ a="", b=0 } = {}): void {
     // ...
 }
-f(); // 좋아요, 기본값 { a: "", b: 0 }
+f();
 
        
 
        
-
        위의 코드는 나중에 handbook에서 설명할 유형 추론의 한 예제입니다.
        
+
        위 코드는 타입 추론의 예제이며 이후 핸드북에서 설명합니다.
        
 
        
-
        그런 다음 기본 초기화가 아닌 비구조화 프로퍼티에 대한 선택적인 프로퍼티를 기본값으로 지정한다는 것을 기억해야 합니다.
        c에서 b는 선택사항으로 지정되었다는 것을 기억하세요.
        
+
        그런 다음, 선택적 프로퍼티를 위해 기본 초기화 대신 구조 분해될 프로퍼티에 기본 값을 주어야 한다는 걸 기억해야 합니다.
+C 가 b를 선택적으로 정의했다는 것을 기억하세요:
        
 
        function f({ a, b = 0 } = { a: "" }): void {
     // ...
 }
-f({ a: "yes" }); // 좋아요, 기본값 b = 0
-f(); // 좋아요, 기본값은 { a:"" }이며 이 경우 기본값은 b = 0입니다.
-f({}); // 오류, 인수를 제공하려면 'a'가 필요합니다.
+f({ a: "yes" }); // 성공, 기본값으로 b = 0 입니다.
+f(); // 성공, 기본 값은 { a: "" } 이고 b = 0 입니다.
+f({}); // 오류, 매개 변수가 주어지면 `a`가 필요합니다.
 
        
-
        비구조화를 조심히 사용하세요.
        앞의 예제에서 보여 주듯이 가장 단순한 비구조화 표현식을 제외하고는 혼란스럽습니다.
        이름 바꾸기 기본값 및 타입을 주석으로 써놓지 않고는 이해하기 힘든 깊은 형태를 비구조화하는 것은 특히 그렇습니다.
        
-
        비구조화 표현식은 작고 심플하게 유지하세요.
        
-
        직접 생성한 비구조화를 항상 스스로 쓸 수 있어야 합니다.
        
-
        전개 연산자 (Spread)
        
-
        전개는 비구조화의 반대입니다.
        배열을 다른 배열로 객체를 다른 객체로 전개하는 것을 허용합니다.
        
-
        예를 들어:
        
+
        구조 분해를 주의해서 사용하세요.
+앞에 예제에서 알 수 있듯이, 가장 간단한 구조 분해 표현식 이외의 것들은 혼란스럽습니다.
+심지어 이름 변경, 기본값, 타입 표시가 없더라도 깊게 중첩된 구조 분해는 정말 이해하기가 힘듭니다.
+구조 분해 표현식을 작고 간단하게 유지하세요.
+당신은 언제나 구조 분해가 만드는 과제를 당신 손으로 만들 수 있습니다.
        
+
        전개 (Spread)
        
+
        전개 연산자는 구조 분해와 반대입니다.
+이는 배열을 다른 배열 안에, 혹은 객체를 다른 객체 안에 전개하도록 해줍니다.
+예를 보겠습니다:
        
 
        let first = [1, 2];
 let second = [3, 4];
 let bothPlus = [0, ...first, ...second, 5];
 
        
-
        이것은 bothPlus에 [0, 1, 2, 3, 4, 5]값을 부여합니다.
        전개는 first와 second의 얕은 복사본을 만듭니다. 그들은 전개에 의해 변하지 않습니다.
        
-
        또한 객체를 전개 할 수도 있습니다.
        
+
        이는 bothPlus에 [0, 1, 2, 3, 4, 5]라는 값을 줍니다.
+전개는 first와 second의 얕은 복사를 만듭니다.
+이들은 전개에 의해 변하지 않습니다.
        
+
        또한 객체를 전개할 수 있습니다:
        
 
        let defaults = { food: "spicy", price: "$$", ambiance: "noisy" };
 let search = { ...defaults, food: "rich" };
 
        
-
        현재 search의 값은 { food: "rich", price: "$$", ambiance: "noisy" }입니다.
        객체의 전개는 배열의 전개보다 복잡합니다.
        배열은 전개를 왼쪽에서 오른쪽으로 진행하지만 결과는 여전히 객체입니다.
        이것은 나중에 전개한 객체의 프로퍼티가 이전에 있던 프로퍼티를 덮어씁니다.
        따라서 끝에 전개할 이전의 코드를 수정하면 다음과 같습니다.
        
+
        여기서 search는 { food: "rich", price: "$$", ambiance: "noisy" }입니다.
+객체 전개는 배열 전개보다 훨씬 복잡합니다.
+배열 전개처럼 왼쪽에서-오른쪽으로 진행되지만 그 결과는 여전히 객체입니다.
+이는 전개 객체 안에서 나중에 오는 프로퍼티가 이전에 오는 프로퍼티를 덮어쓰는 것을 의미합니다.
+그래서 만약에 우리가 이전 예제를 마지막에 전개하도록 수정하면:
        
 
        let defaults = { food: "spicy", price: "$$", ambiance: "noisy" };
 let search = { food: "rich", ...defaults };
 
        
-
        defaults의 food 프로퍼티가 food: "rich"를 덮어쓰게 됩니다. 그러나 이것은 우리가 원한 결과가 아닙니다.'
        
-
        객체 Spread에는 몇 가지 다른 놀라운 한계가 있습니다.
        
-
        첫번째, 열거 가능 속성(own, enumerable properties) 객체에 포함됩니다.
        기본적으로 객체의 인스턴스를 전개할 때 메서드를 잃어버린다는 것을 의미합니다.
        
+
        defaults안에 food 프로퍼티는 food: "rich"를 덮어쓰는데, 이 경우 우리가 의도한 것은 아닙니다.
        
+
        객체 전개는 또한 몇몇의 놀라운 제한점이 잇습니다.
+첫째로, 이는 오직 객체
+본인의 열거 가능한 프로퍼티만 해당한다는 것입니다.
+기본적으로, 이는 객체의 인스턴스를 전개하면 메서드를 잃게 된다는 것을 뜻합니다:
        
 
        class C {
   p = 12;
   m() {
@@ -1129,10 +1250,11 @@ 
        전개 Å
 }
 let c = new C();
 let clone = { ...c };
-clone.p; // 좋아요
+clone.p; // 성공
 clone.m(); // 오류!
 
        
-
        두번째, Typescript 컴파일러는 일반 함수의 매개변수를 전개로 허용하지 않습니다.
        이 기능은 향후 버전의 언어에서 사용될 것으로 예상됩니다.
        
+
        두 번째로, TypeScript 컴파일러는 제네릭 함수에서 타입 매개변수를 전개하는 것을 허용하지 않습니다.
+이 기능은 이후 버전에서 예상되는 기능입니다.
        
 
                                 
                                 
        
@@ -1176,7 +1298,7 @@ 
        No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"변수 선언","level":"3.2","depth":1,"next":{"title":"인터페이스","level":"3.3","depth":1,"path":"pages/Interfaces.md","ref":"pages/Interfaces.md","articles":[]},"previous":{"title":"기본 타입","level":"3.1","depth":1,"path":"pages/Basic Types.md","ref":"pages/Basic Types.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Variable Declarations.md","mtime":"2019-06-14T05:35:15.554Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"변수 선언","level":"3.2","depth":1,"next":{"title":"인터페이스","level":"3.3","depth":1,"path":"pages/Interfaces.md","ref":"pages/Interfaces.md","articles":[]},"previous":{"title":"기본 타입","level":"3.1","depth":1,"path":"pages/Basic Types.md","ref":"pages/Basic Types.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/Variable Declarations.md","mtime":"2020-04-22T15:29:36.180Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/declaration files/By Example.html b/pages/declaration files/By Example.html
index 790f09ff..e86e07ed 100644
--- a/pages/declaration files/By Example.html	
+++ b/pages/declaration files/By Example.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
      • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
        • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
      • 
+        
      • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
        • 
+    
+        
      • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
        • 
     
-        
      • 
+        
      • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
        • 
     
-        
      • 
+        
      • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
      • 릴리즈 노트
        • 
+        
+        
+    
+        
      • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
        • 
+    
+
+    
 
     
      • 
 
@@ -711,97 +757,97 @@ 
        
     
                                 
        
                                 
-                                
        Introduction
        
-
        The purpose of this guide is to teach you how to write a high-quality definition file.
-This guide is structured by showing documentation for some API, along with sample usage of that API,
-  and explaining how to write the corresponding declaration.
        
-
        These examples are ordered in approximately increasing order of complexity.
        
+                                
        소개 (Introduction)
        
+
        이 가이드는 양질의 선언 파일을 작성하는 방법을 설명하기 위해 작성되었습니다.
+이 가이드는 일부 API 문서를 해당 API 사용 예시와 함께 보여주고,
+  상응하는 선언을 작성하는 방법을 설명합니다.
        
+
        예제는 대체로 후반부로 갈수록 복잡해집니다.
        
 
-
        The Examples
        
-
        Global Variables
        
-
        Documentation
        
+
        예제 (The Examples)
        
+
        전역 변수 (Global Variables)
        
+
        문서
        
 
        
-
        The global variable foo contains the number of widgets present.
        
+
        전역 변수 foo는 존재하는 위젯의 수를 포함합니다.
        
 
        
-
        Code
        
+
        코드
        
 
        console.log("Half the number of widgets is " + (foo / 2));
 
        
-
        Declaration
        
-
        Use declare var to declare variables.
-If the variable is read-only, you can use declare const.
-You can also use declare let if the variable is block-scoped.
        
-
        /** The number of widgets present */
+
        선언
        
+
        변수를 선언하기 위해 declare var를 사용하세요.
+만약 변수가 읽기-전용이라면, declare const를 사용하세요.
+변수가 블록-스코프인 경우 declare let 또한 사용할 수 있습니다.
        
+
        /** 존재하는 위젯의 수 */
 declare var foo: number;
 
        
-
        Global Functions
        
-
        Documentation
        
+
        전역 함수 (Global Functions)
        
+
        문서
        
 
        
-
        You can call the function greet with a string to show a greeting to the user.
        
+
        사용자에게 인사말을 보여주기 위해 greet 함수를 호출할 수 있습니다.
        
 
        
-
        Code
        
+
        코드
        
 
        greet("hello, world");
 
        
-
        Declaration
        
-
        Use declare function to declare functions.
        
+
        선언
        
+
        함수를 선언하기 위해 declare function을 사용하세요.
        
 
        declare function greet(greeting: string): void;
 
        
-
        Objects with Properties
        
-
        Documentation
        
+
        프로퍼티를 갖는 객체 (Objects with Properties)
        
+
        문서
        
 
        
-
        The global variable myLib has a function makeGreeting for creating greetings,
-and a property numberOfGreetings indicating the number of greetings made so far.
        
+
        전역 변수 myLib에는 인사말을 만드는 함수 makeGreeting와,
+지금까지 생성한 인사말의 수를 가리키는 numberOfGreetings 프로퍼티가 있습니다.
        
 
        
-
        Code
        
+
        코드
        
 
        let result = myLib.makeGreeting("hello, world");
 console.log("The computed greeting is:" + result);
 
 let count = myLib.numberOfGreetings;
 
        
-
        Declaration
        
-
        Use declare namespace to describe types or values accessed by dotted notation.
        
+
        선언
        
+
        점 표기법으로 접근하는 타입이나 값을 설명하기 위해 declare namespace를 사용하세요.
        
 
        declare namespace myLib {
     function makeGreeting(s: string): string;
     let numberOfGreetings: number;
 }
 
        
-
        Overloaded Functions
        
-
        Documentation
        
-
        The getWidget function accepts a number and returns a Widget, or accepts a string and returns a Widget array.
        
-
        Code
        
+
        오버로드된 함수 (Overloaded Functions)
        
+
        문서
        
+
        getWidget 함수는 숫자를 인자로 받아 Widget을 반환하거나, 문자열을 인자로 받아 Widget 배열을 반환합니다.
        
+
        코드
        
 
        let x: Widget = getWidget(43);
 
 let arr: Widget[] = getWidget("all of them");
 
        
-
        Declaration
        
+
        선언
        
 
        declare function getWidget(n: number): Widget;
 declare function getWidget(s: string): Widget[];
 
        
-
        Reusable Types (Interfaces)
        
-
        Documentation
        
+
        재사용 가능한 타입 (인터페이스) (Reusable Types (Interfaces))
        
+
        문서
        
 
        
-
        When specifying a greeting, you must pass a GreetingSettings object.
-This object has the following properties:
        
-
        1 - greeting: Mandatory string
        
-
        2 - duration: Optional length of time (in milliseconds)
        
-
        3 - color: Optional string, e.g. '#ff00ff'
        
+
        greeting을 명시할 때, 반드시 GreetingSettings 객체를 전달해야 합니다.
+이 객체는 다음의 프로퍼티를 갖고 있습니다:
        
+
        1 - greeting: 필수 문자열
        
+
        2 - duration: 선택적 시간 (밀리초)
        
+
        3 - color: 선택적 문자열, 예. '#ff00ff'
        
 
        
-
        Code
        
+
        코드
        
 
        greet({
   greeting: "hello world",
   duration: 4000
 });
 
        
-
        Declaration
        
-
        Use an interface to define a type with properties.
        
+
        선언
        
+
        프로퍼티를 갖는 타입을 정의하기 위해 interface를 사용하세요.
        
 
        interface GreetingSettings {
   greeting: string;
   duration?: number;
@@ -810,12 +856,12 @@ 
        Reusable Types (Interfaces)
        
 
 declare function greet(setting: GreetingSettings): void;
 
        
-
        Reusable Types (Type Aliases)
        
-
        Documentation
        
+
        재사용 가능한 타입 (타입 별칭) (Reusable Types (Type Aliases))
        
+
        문서
        
 
        
-
        Anywhere a greeting is expected, you can provide a string, a function returning a string, or a Greeter instance.
        
+
        인사말이 예상되는 어느 곳에나, string, string을 반환하는 함수, 또는 Greeter 인스턴스를 전달할 수 있습니다.
        
 
        
-
        Code
        
+
        코드
        
 
        function getGreeting() {
     return "howdy";
 }
@@ -825,25 +871,25 @@ 
        Reusable Types (Type Aliases)
        
 greet(getGreeting);
 greet(new MyGreeter());
 
        
-
        Declaration
        
-
        You can use a type alias to make a shorthand for a type:
        
-
        type GreetingLike = string | (() => string) | MyGreeter;
+
        선언
        
+
        타입에 대한 약칭으로 타입 별칭을 사용할 수 있습니다:
        
+
        type GreetingLike = string | (() => string) | Greeter;
 
 declare function greet(g: GreetingLike): void;
 
        
-
        Organizing Types
        
-
        Documentation
        
+
        타입 구조화하기 (Organizing Types)
        
+
        문서
        
 
        
-
        The greeter object can log to a file or display an alert.
-You can provide LogOptions to .log(...) and alert options to .alert(...)
        
+
        greeter 객체는 파일에 로그를 작성하거나 경고 창을 띄울 수 있습니다.
+로그 옵션을 .log(...) 내부에, 경고 창 옵션을 .alert(...) 내부에 전달할 수 있습니다.
        
 
        
-
        Code
        
+
        코드
        
 
        const g = new Greeter("Hello");
 g.log({ verbose: true });
 g.alert({ modal: false, title: "Current Greeting" });
 
        
-
        Declaration
        
-
        Use namespaces to organize types.
        
+
        선언
        
+
        타입을 구조화하기 위해 네임스페이스를 사용하세요.
        
 
        declare namespace GreetingLib {
     interface LogOptions {
         verbose?: boolean;
@@ -855,7 +901,7 @@ 
        Organizing Types
        
     }
 }
 
        
-
        You can also create nested namespaces in one declaration:
        
+
        중첩된 네임스페이스를 하나의 선언으로 만들 수 있습니다:
        
 
        declare namespace GreetingLib.Options {
     // Refer to via GreetingLib.Options.Log
     interface Log {
@@ -868,12 +914,12 @@ 
        Organizing Types
        
     }
 }
 
        
-
        Classes
        
-
        Documentation
        
+
        클래스 (Classes)
        
+
        문서
        
 
        
-
        You can create a greeter by instantiating the Greeter object, or create a customized greeter by extending from it.
        
+
        Greeter 객체를 인스턴스화해서 greeter를 생성하거나, 이 객체를 상속해서 커스텀 greeter를 생성할 수 있습니다.
        
 
        
-
        Code
        
+
        코드
        
 
        const myGreeter = new Greeter("hello, world");
 myGreeter.greeting = "howdy";
 myGreeter.showGreeting();
@@ -884,9 +930,9 @@ 
        Classes
        
     }
 }
 
        
-
        Declaration
        
-
        Use declare class to describe a class or class-like object.
-Classes can have properties and methods as well as a constructor.
        
+
        선언
        
+
        클래스 혹은 클래스-같은 객체를 설명하기 위해 declare class를 사용하세요.
+클래스는 생성자 뿐만 아니라 프로퍼티와 메서드를 가질 수 있습니다.
        
 
        declare class Greeter {
     constructor(greeting: string);
 
@@ -957,7 +1003,7 @@ 
        No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"By Example","level":"4.3","depth":1,"next":{"title":"Do's and Don'ts","level":"4.4","depth":1,"path":"pages/declaration files/Do's and Don'ts.md","ref":"pages/declaration files/Do's and Don'ts.md","articles":[]},"previous":{"title":"Library Structures","level":"4.2","depth":1,"path":"pages/declaration files/Library Structures.md","ref":"pages/declaration files/Library Structures.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/declaration files/By Example.md","mtime":"2019-06-14T05:32:52.252Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"../..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"By Example","level":"4.3","depth":1,"next":{"title":"Do's and Don'ts","level":"4.4","depth":1,"path":"pages/declaration files/Do's and Don'ts.md","ref":"pages/declaration files/Do's and Don'ts.md","articles":[]},"previous":{"title":"Library Structures","level":"4.2","depth":1,"path":"pages/declaration files/Library Structures.md","ref":"pages/declaration files/Library Structures.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/declaration files/By Example.md","mtime":"2020-04-22T15:29:36.181Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"../..","book":{"language":""}});
         });
     
 
diff --git a/pages/declaration files/Consumption.html b/pages/declaration files/Consumption.html
index 6894f97a..7b0e36df 100644
--- a/pages/declaration files/Consumption.html	
+++ b/pages/declaration files/Consumption.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
      • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
        • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
      • 
+        
      • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
        • 
+    
+        
      • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
        • 
     
-        
      • 
+        
      • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
        • 
     
-        
      • 
+        
      • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
      • 릴리즈 노트
        • 
+        
+        
+    
+        
      • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
        • 
+    
+
+    
 
     
      • 
 
@@ -711,30 +757,30 @@ 
        
     
                                 
        
                                 
-                                
        In TypeScript 2.0, it has become significantly easier to consume declaration files, in acquiring, using, and finding them.
-This page details exactly how to do all three.
        
-
        Downloading
        
-
        Getting type declarations in TypeScript 2.0 and above requires no tools apart from npm.
        
-
        As an example, getting the declarations for a library like lodash takes nothing more than the following command
        
+                                
        TypeScript 2.0에서는 선언 파일을 얻고, 사용하고, 찾는 것이 훨씬 쉬워졌습니다.
+이 페이지에서 세 가지를 어떻게 하는지 정확하게 설명합니다.
        
+
        다운로드 (Downloading)
        
+
        TypeScript 2.0 이상에서 타입 선언을 가져오는데 npm 이외의 도구는 필요하지 않습니다.
        
+
        예를 들어, lodash와 같은 라이브러리에 대한 선언을 얻는 것은 다음 명령어로 충분합니다.
        
 
        npm install --save @types/lodash
 
        
-
        It is worth noting that if the npm package already includes its declaration file as described in Publishing, downloading the corresponding @types package is not needed.
        
-
        Consuming
        
-
        From there you’ll be able to use lodash in your TypeScript code with no fuss.
-This works for both modules and global code.
        
-
        For example, once you’ve npm install-ed your type declarations, you can use imports and write
        
+
        Publishing에서 설명한 데로 npm 패키지에 이미 선언 파일이 포함되어 있다면, @types 패키지를 설치할 필요는 없다는 걸 유의하세요.
        
+
        사용하기 (Consuming)
        
+
        TypeScript 코드에 별 어려움 없이 lodash를 사용할 수 있습니다.
+이는 모듈 및 전역 코드에 모두 적용됩니다.
        
+
        예를 들어, 타입 선언에 대해 npm install을 한 번만 수행하면, import 하고 사용할 수 있고
        
 
        import * as _ from "lodash";
 _.padStart("Hello TypeScript!", 20, " ");
 
        
-
        or if you’re not using modules, you can just use the global variable _.
        
+
        또는 모듈을 사용하지 않는다면, 전역 변수 _ 를 사용할 수 있습니다.
        
 
        _.padStart("Hello TypeScript!", 20, " ");
 
        
-
        Searching
        
-
        For the most part, type declaration packages should always have the same name as the package name on npm, but prefixed with @types/,
-  but if you need, you can check out https://aka.ms/types to find the package for your favorite library.
        
+
        찾기 (Searching)
        
+
        대부분의 경우, 타입 선언 패키지 이름은 항상 npm 상의 패키지 이름과 같아야 하지만, @types/ 가 앞에 붙어야 합니다.
+  하지만 필요시 https://aka.ms/types 를 방문해 선호하는 라이브러리의 패키지를 찾으세요.
        
 
        
-
        Note: if the declaration file you are searching for is not present, you can always contribute one back and help out the next developer looking for it.
-Please see the DefinitelyTyped contribution guidelines page for details.
        
+
        참고: 만약 찾고자 하는 선언 파일이 없는 경우, 언제든지 기여하고, 다음 개발자가 이를 찾는 데 도움을 줄 수 있습니다.
+자세한 내용은 DefinitelyTyped의 기여 지침 페이지를 참고하세요.
        
 
        
 
                                 
@@ -779,7 +825,7 @@ 
        No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Consumption","level":"4.8","depth":1,"next":{"title":"tsconfig.json","level":"5.1","depth":1,"path":"pages/tsconfig.json.md","ref":"pages/tsconfig.json.md","articles":[]},"previous":{"title":"Publishing","level":"4.7","depth":1,"path":"pages/declaration files/Publishing.md","ref":"pages/declaration files/Publishing.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/declaration files/Consumption.md","mtime":"2019-06-14T05:32:52.253Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"../..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Consumption","level":"4.8","depth":1,"next":{"title":"tsconfig.json","level":"5.1","depth":1,"path":"pages/tsconfig.json.md","ref":"pages/tsconfig.json.md","articles":[]},"previous":{"title":"Publishing","level":"4.7","depth":1,"path":"pages/declaration files/Publishing.md","ref":"pages/declaration files/Publishing.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/declaration files/Consumption.md","mtime":"2020-04-22T15:29:36.181Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"../..","book":{"language":""}});
         });
     
 
diff --git a/pages/declaration files/Deep Dive.html b/pages/declaration files/Deep Dive.html
index a7491bcc..eb403fd2 100644
--- a/pages/declaration files/Deep Dive.html	
+++ b/pages/declaration files/Deep Dive.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
      • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
        • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
      • 
+        
      • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
        • 
+    
+        
      • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
        • 
     
-        
      • 
+        
      • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
        • 
     
-        
      • 
+        
      • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
      • 릴리즈 노트
        • 
+        
+        
+    
+        
      • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
        • 
+    
+
+    
 
     
      • 
 
@@ -711,151 +757,151 @@ 
        
     
                                 
        
                                 
-                                
        Definition File Theory: A Deep Dive
        
-
        Structuring modules to give the exact API shape you want can be tricky.
-For example, we might want a module that can be invoked with or without new to produce different types,
-  has a variety of named types exposed in a hierarchy,
-  and has some properties on the module object as well.
        
-
        By reading this guide, you'll have the tools to write complex definition files that expose a friendly API surface.
-This guide focuses on module (or UMD) libraries because the options here are more varied.
        
-
        Key Concepts
        
-
        You can fully understand how to make any shape of definition
-  by understanding some key concepts of how TypeScript works.
        
-
        Types
        
-
        If you're reading this guide, you probably already roughly know what a type in TypeScript is.
-To be more explicit, though, a type is introduced with:
        
+                                
        정의 파일 이론: 심층 분석 (Definition File Theory: A Deep Dive)
        
+
        원하는 API 형태를 제공하는 모듈을 만드는 것은 까다로울 수 있습니다.
+예를 들어, new의 사용에 따라 호출할 때 다른 타입을 생성하는 모듈을 원할 수 있고,
+  계층에 노출 된 다양한 명명된 타입을 가지고 있으며,
+  모듈 객체에 대한 여러 프로퍼티도 가질 수 있습니다.
        
+
        이 가이드에서는, 익숙한 API를 노출하는 복잡한 정의 파일에 대해 작성하는 도구를 제공합니다.
+또한 옵션이 다양하기 때문에 여기서는 모듈 (또는 UMD) 라이브러리에 중점을 둡니다.
        
+
        주요 컨셉 (Key Concepts)
        
+
        TypeScript 작동 방식에 대해 여러 주요 개념을 이해하여
+  정의의 형태를 만드는 방법을 완전히 이해할 수 있습니다.
        
+
        타입 (Types)
        
+
        이 가이드를 읽고 있다면, 아마도 TypeScript의 타입에 대해 이미 알고 있을 것입니다.
+보다 명확하게하기 위해, 다음과 같이 타입이 도입됩니다:
        
 
          
-
        • A type alias declaration (type sn = number | string;)
          • 
-
        • An interface declaration (interface I { x: number[]; })
          • 
-
        • A class declaration (class C { })
          • 
-
        • An enum declaration (enum E { A, B, C })
          • 
-
        • An import declaration which refers to a type
          • 
+
        • 타입 별칭 선언 (type sn = number | string;)
          • 
+
        • 인터페이스 선언 (interface I { x: number[]; })
          • 
+
        • 클래스 선언 (class C { })
          • 
+
        • 열거형 선언 (enum E { A, B, C })
          • 
+
        • 타입을 가리키는 import 선언
          • 
 
        
-
        Each of these declaration forms creates a new type name.
        
-
        Values
        
-
        As with types, you probably already understand what a value is.
-Values are runtime names that we can reference in expressions.
-For example let x = 5; creates a value called x.
        
-
        Again, being explicit, the following things create values:
        
+
        이러한 각 선언 형태는 새로운 타입 이름을 만듭니다.
        
+
        값 (Values)
        
+
        타입과 마찬가지로 값이 무엇인지 이미 알고 있을 것입니다.
+값은 표현식에서 참조할 수 있는 런타임 이름입니다.
+예를 들어 let x = 5;에서는 x라고 불리는 값을 생성합니다.
        
+
        다시 명확하게 말하자면, 다음과 같이 값을 만듭니다:
        
 
          
-
        • let, const, and var declarations
          • 
-
        • A namespace or module declaration which contains a value
          • 
-
        • An enum declaration
          • 
-
        • A class declaration
          • 
-
        • An import declaration which refers to a value
          • 
-
        • A function declaration
          • 
+
        • let, const, 그리고 var 선언
          • 
+
        • 값을 포함하는 네임스페이스 또는 모듈 선언
          • 
+
        • 열거형 선언
          • 
+
        • 클래스 선언
          • 
+
        • 값을 참조하는 import 선언
          • 
+
        • 함수 선언
          • 
 
        
-
        Namespaces
        
-
        Types can exist in namespaces.
-For example, if we have the declaration let x: A.B.C,
-  we say that the type C comes from the A.B namespace.
        
-
        This distinction is subtle and important -- here, A.B is not necessarily a type or a value.
        
-
        Simple Combinations: One name, multiple meanings
        
-
        Given a name A, we might find up to three different meanings for A: a type, a value or a namespace.
-How the name is interpreted depends on the context in which it is used.
-For example, in the declaration let m: A.A = A;,
-  A is used first as a namespace, then as a type name, then as a value.
-These meanings might end up referring to entirely different declarations!
        
-
        This may seem confusing, but it's actually very convenient as long as we don't excessively overload things.
-Let's look at some useful aspects of this combining behavior.
        
-
        Built-in Combinations
        
-
        Astute readers will notice that, for example, class appeared in both the type and value lists.
-The declaration class C { } creates two things:
-  a type C which refers to the instance shape of the class,
-  and a value C which refers to the constructor function of the class.
-Enum declarations behave similarly.
        
-
        User Combinations
        
-
        Let's say we wrote a module file foo.d.ts:
        
+
        네임스페이스 (Namespaces)
        
+
        타입은 네임스페이스 안에 존재할 수 있습니다.
+예를 들어, let x: A.B.C 이란 선언이 있다면,
+  타입 C는 A.B 네임스페이스에서 온 것 입니다.
        
+
        이 구별은 미묘하지만 중요합니다 -- 여기서 A.B는 타입이거나 값일 필요는 없습니다.
        
+
        간단한 조합: 하나의 이름, 여러 의미 (Simple Combinations: One name, multiple meanings)
        
+
        A라는 이름이 있으면, A에 대해 타입, 값 또는 네임스페이스라는 세 가지 다른 의미를 찾을 수 있습니다.
+이름을 해석하는 방법은 사용하는 컨텍스트에 따라 다릅니다.
+예를 들어 let m: A.A = A; 선언에서,
+  A는 먼저 네임스페이스로 사용 된 다음, 타입의 이름으로, 그 다음 값으로 사용됩니다.
+즉 완전히 다른 선언을 의미할 수 있습니다!
        
+
        약간은 혼란스러워 보이지만, 과하게 사용하지 않는 한 실제로 매우 편리합니다.
+결합 동작의 유용한 측면을 살펴 보겠습니다.
        
+
        내부 조합 (Built-in Combinations)
        
+
        영리한 사람이라면, 타입과 값 목록에서 클래스가 둘 다 나온 것을 눈치챘을 것입니다.
+class C { } 선언은 두 가지를 만듭니다:
+  클래스 인스턴스의 형태를 나타내는 타입 C와
+  클래스 생성자를 나타내는 값 C 입니다.
+열거형 선언도 비슷하게 동작합니다.
        
+
        사용자 조합 (User Combinations)
        
+
        모듈 파일 foo.d.ts을 작성했습니다:
        
 
        export var SomeVar: { a: SomeType };
 export interface SomeType {
   count: number;
 }
 
        
-
        Then consumed it:
        
+
        그 다음 사용했습니다:
        
 
        import * as foo from './foo';
 let x: foo.SomeType = foo.SomeVar.a;
 console.log(x.count);
 
        
-
        This works well enough, but we might imagine that SomeType and SomeVar were very closely related
-  such that you'd like them to have the same name.
-We can use combining to present these two different objects (the value and the type) under the same name Bar:
        
+
        잘 작동하지만, SomeType과 SomeVar는 이름이 같도록
+  밀접하게 관련되어 있다고 상상할 수 있습니다.
+결합을 사용하여 같은 이름 Bar로 두 가지 다른 객체 (값과 타입)를 표시 할 수 있습니다:
        
 
        export var Bar: { a: Bar };
 export interface Bar {
   count: number;
 }
 
        
-
        This presents a very good opportunity for destructuring in the consuming code:
        
+
        이 경우 사용하는 코드를 구조 분해할 수 있는 아주 좋은 기회입니다:
        
 
        import { Bar } from './foo';
 let x: Bar = Bar.a;
 console.log(x.count);
 
        
-
        Again, we've used Bar as both a type and a value here.
-Note that we didn't have to declare the Bar value as being of the Bar type -- they're independent.
        
-
        Advanced Combinations
        
-
        Some kinds of declarations can be combined across multiple declarations.
-For example, class C { } and interface C { } can co-exist and both contribute properties to the C types.
        
-
        This is legal as long as it does not create a conflict.
-A general rule of thumb is that values always conflict with other values of the same name unless they are declared as namespaces,
-  types will conflict if they are declared with a type alias declaration (type s = string),
-  and namespaces never conflict.
        
-
        Let's see how this can be used.
        
-
        Adding using an interface
        
-
        We can add additional members to an interface with another interface declaration:
        
+
        여기서도 Bar를 타입과 값으로 사용했습니다.
+Bar 값을 Bar 타입으로 선언할 필요가 없다는 점을 유의하세요 -- 저 둘은 독립적입니다.
        
+
        고급 결합 (Advanced Combinations)
        
+
        선언은 여러 개의 선언에 걸쳐 결합될 수 있습니다.
+예를 들어, class C { }와 interface C { } 같이 결합할 수 있으며 둘 다 C 타입에 프로퍼티를 추가합니다.
        
+
        충돌을 일으키지 않는다면 충분히 합법적입니다.
+일반적인 경험 법칙은 값의 이름이 네임스페이스로 선언되지 않는 한 항상 같은 이름의 다른 값과 충돌하고,
+  타입 별칭 선언(type s = string)으로 선언 된 경우 타입이 충돌하며,
+  네임스페이스와는 절대로 충돌하지 않는 것입니다.
        
+
        어떻게 사용되는지 살펴보겠습니다.
        
+
        인터페이스를 사용하여 추가하기 (Adding using an interface)
        
+
        인터페이스에 다른 인터페이스 선언을 사용하여 멤버를 추가할 수 있습니다:
        
 
        interface Foo {
   x: number;
 }
-// ... elsewhere ...
+// ... 다른 위치 ...
 interface Foo {
   y: number;
 }
 let a: Foo = ...;
-console.log(a.x + a.y); // OK
+console.log(a.x + a.y); // 성공
 
        
-
        This also works with classes:
        
+
        클래스와도 같이 동작합니다:
        
 
        class Foo {
   x: number;
 }
-// ... elsewhere ...
+// ... 다른 위치 ...
 interface Foo {
   y: number;
 }
 let a: Foo = ...;
-console.log(a.x + a.y); // OK
+console.log(a.x + a.y); // 성공
 
        
-
        Note that we cannot add to type aliases (type s = string;) using an interface.
        
-
        Adding using a namespace
        
-
        A namespace declaration can be used to add new types, values, and namespaces in any way which does not create a conflict.
        
-
        For example, we can add a static member to a class:
        
+
        단, 타입 별칭 (type s = string;)에는 인터페이스를 사용해서 추가할 수 없습니다.
        
+
        네임스페이스를 사용하여 추가하기 (Adding using a namespace)
        
+
        네임스페이스 선언은 충돌을 일으키지 않는 방식으로 새로운 타입, 값 그리고 네임스페이스를 추가할 수 있습니다.
        
+
        예를 들어, 클래스에 정적 멤버를 추가할 수 있습니다:
        
 
        class C {
 }
-// ... elsewhere ...
+// ... 다른 위치 ...
 namespace C {
   export let x: number;
 }
-let y = C.x; // OK
+let y = C.x; // 성공
 
        
-
        Note that in this example, we added a value to the static side of C (its constructor function).
-This is because we added a value, and the container for all values is another value
-  (types are contained by namespaces, and namespaces are contained by other namespaces).
        
-
        We could also add a namespaced type to a class:
        
+
        위 예제에서 C의 정적 측면(생성자 함수)에 값을 추가했습니다.
+값을 추가 했고 모든 값에 대한 컨테이너가 다르기 때문입니다.
+  (타입은 네임스페이스에 포함되고 네임스페이스는 다른 네임스페이스에 포함됩니다).
        
+
        네임스페이스 타입을 클래스에 추가할 수 있습니다:
        
 
        class C {
 }
-// ... elsewhere ...
+// ... 다른 위치 ...
 namespace C {
   export interface D { }
 }
-let y: C.D; // OK
+let y: C.D; // 성공
 
        
-
        In this example, there wasn't a namespace C until we wrote the namespace declaration for it.
-The meaning C as a namespace doesn't conflict with the value or type meanings of C created by the class.
        
-
        Finally, we could perform many different merges using namespace declarations.
-This isn't a particularly realistic example, but shows all sorts of interesting behavior:
        
+
        이 예제에서 namespace 선언을 작성할 때까지 네임스페이스 C는 없었습니다.
+네임스페이스 C는 클래스에 의해 생성된 C의 값 또는 타입과 충돌하지 않습니다.
        
+
        마지막으로 namespace 선언을 사용하여 다양한 병합을 할 수 있습니다.
+특히 현실적인 예는 아니지만, 흥미로운 동작을 확인할 수 있습니다:
        
 
        namespace X {
   export interface Y { }
   export class Z { }
 }
 
-// ... elsewhere ...
+// ... 다른 위치 ...
 namespace X {
   export var Y: number;
   export namespace Z {
@@ -864,25 +910,25 @@ 
        Adding using a namespace
        
 }
 type X = string;
 
        
-
        In this example, the first block creates the following name meanings:
        
+
        위 예제에서 첫 번째 블록은 다음 이름의 의미를 만듭니다:
        
 
          
-
        • A value X (because the namespace declaration contains a value, Z)
          • 
-
        • A namespace X (because the namespace declaration contains a type, Y)
          • 
-
        • A type Y in the X namespace
          • 
-
        • A type Z in the X namespace (the instance shape of the class)
          • 
-
        • A value Z that is a property of the X value (the constructor function of the class)
          • 
+
        • 값 X (네임스페이스 선언은 값 Z를 포함하기 때문입니다)
          • 
+
        • 네임스페이스 X (네임스페이스 선언은 타입 Y를 포함하기 때문입니다)
          • 
+
        • X 네임스페이스 안의 타입 Y
          • 
+
        • X 네임스페이스 안의 타입 Z (클래스의 인스턴스 형태)
          • 
+
        • X 값의 프로퍼티인 값 Z (클래스의 생성자 함수)
          • 
 
        
-
        The second  block creates the following name meanings:
        
+
        두 번째 블록은 다음 이름의 의미를 만듭니다:
        
 
          
-
        • A value Y (of type number) that is a property of the X value
          • 
-
        • A namespace Z
          • 
-
        • A value Z that is a property of the X value
          • 
-
        • A type C in the X.Z namespace
          • 
-
        • A value C that is a property of the X.Z value
          • 
-
        • A type X
          • 
+
        • X 값의 프로퍼티인 값 Y (number 타입)
          • 
+
        • 네임스페이스 Z
          • 
+
        • X 값의 프로퍼티인 값 Z
          • 
+
        • X.Z 네임스페이스 안의 타입 C
          • 
+
        • X.Z 값의 프로퍼티인 값 C
          • 
+
        • 타입 X
          • 
 
        
-
        Using with export = or import
        
-
        An important rule is that export and import declarations export or import all meanings of their targets.
        
+
        export = or import 사용하기 (Using with export = or import)
        
+
        중요한 규칙은 export와 import 선언이 대상의 모든 의미 를 내보내거나 가져온다는 것 입니다.
        
 
 
                                 
@@ -927,7 +973,7 @@ 
        No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Deep Dive","level":"4.5","depth":1,"next":{"title":"Templates","level":"4.6","depth":1,"path":"pages/declaration files/Templates.md","ref":"pages/declaration files/Templates.md","articles":[]},"previous":{"title":"Do's and Don'ts","level":"4.4","depth":1,"path":"pages/declaration files/Do's and Don'ts.md","ref":"pages/declaration files/Do's and Don'ts.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/declaration files/Deep Dive.md","mtime":"2019-06-14T05:32:52.253Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"../..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Deep Dive","level":"4.5","depth":1,"next":{"title":"Templates","level":"4.6","depth":1,"path":"pages/declaration files/Templates.md","ref":"pages/declaration files/Templates.md","articles":[]},"previous":{"title":"Do's and Don'ts","level":"4.4","depth":1,"path":"pages/declaration files/Do's and Don'ts.md","ref":"pages/declaration files/Do's and Don'ts.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/declaration files/Deep Dive.md","mtime":"2020-04-22T15:29:36.182Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"../..","book":{"language":""}});
         });
     
 
diff --git a/pages/declaration files/Do's and Don'ts.html b/pages/declaration files/Do's and Don'ts.html
index ad1b0077..7e6179a6 100644
--- a/pages/declaration files/Do's and Don'ts.html	
+++ b/pages/declaration files/Do's and Don'ts.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
      • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
        • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
      • 
+        
      • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
        • 
+    
+        
      • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
        • 
     
-        
      • 
+        
      • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
        • 
     
-        
      • 
+        
      • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
      • 릴리즈 노트
        • 
+        
+        
+    
+        
      • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
        • 
+    
+
+    
 
     
      • 
 
@@ -711,76 +757,75 @@ 
        
     
                                 
        
                                 
-                                
        General Types
        
-
        Number, String, Boolean, and Object
        
-
        Don't ever use the types Number, String, Boolean, or Object.
-These types refer to non-primitive boxed objects that are almost never used appropriately in JavaScript code.
        
-
        /* WRONG */
+                                
        일반 타입 (General Types)
        
+
        Number, String, Boolean, Symbol and Object
        
+
        Number, String, Boolean, Symbol, Object 타입을 사용하지 마세요.
+이 타입들은 JavaScript 코드에서 거의 사용되지 않는 비-원시형 박싱된 객체를 가르킵니다.
        
+
        /* 잘못됨 */
 function reverse(s: String): String;
 
        
-
        Do use the types number, string, and boolean.
        
-
        /* OK */
+
        number, string, boolean, symbol 타입을 사용 하세요.
        
+
        /* 좋음 */
 function reverse(s: string): string;
 
        
-
        Instead of Object, use the non-primitive object type (added in TypeScript 2.2).
        
-
        Generics
        
-
        Don't ever have a generic type which doesn't use its type parameter.
-See more details in TypeScript FAQ page.
        
+
        Object 대신에, TypeScript 2.2 에 추가된 비-원시형 object타입을 사용하세요.
        
+
        제네릭 (Generics)
        
+
        타입 매개변수를 사용하지 않는 제네릭 타입을 사용하지 마세요. 더 자세한 내용은 TypeScript FAQ 페이지에서 확인하세요.
        
 
-
        Callback Types
        
-
        Return Types of Callbacks
        
+
        콜백 타입 (Callback Types)
        
+
        콜백의 반환 타입 (Return Types of Callbacks)
        
 
-
        Don't use the return type any for callbacks whose value will be ignored:
        
-
        /* WRONG */
+
        사용하지 않는 콜백의 반환 값 타입에 any를 사용하지 마세요:
        
+
        /* 잘못됨 */
 function fn(x: () => any) {
     x();
 }
 
        
-
        Do use the return type void for callbacks whose value will be ignored:
        
-
        /* OK */
+
        사용하지 않는 콜백의 반환 값 타입은 void를 사용하세요:  
        
+
        /* 좋음 */
 function fn(x: () => void) {
     x();
 }
 
        
-
        Why: Using void is safer because it prevents you from accidently using the return value of x in an unchecked way:
        
+
        이유: void를 사용하면 실수로 x의 반환 값을 사용하는 것을 방지 할 수 있기 때문에 더 안전합니다.:
        
 
        function fn(x: () => void) {
     var k = x(); // oops! meant to do something else
     k.doSomething(); // error, but would be OK if the return type had been 'any'
 }
 
        
-
        Optional Parameters in Callbacks
        
-
        Don't use optional parameters in callbacks unless you really mean it:
        
-
        /* WRONG */
+
        콜백에서 선택적 매개변수 (Optional Parameters in Callbacks)
        
+
        정말 의도한 것이 아니라면 콜백에 선택적 매개변수를 사용하지 마세요:
        
+
        /* 잘못됨 */
 interface Fetcher {
     getObject(done: (data: any, elapsedTime?: number) => void): void;
 }
 
        
-
        This has a very specific meaning: the done callback might be invoked with 1 argument or might be invoked with 2 arguments.
-The author probably intended to say that the callback might not care about the elapsedTime parameter,
-  but there's no need to make the parameter optional to accomplish this --
-  it's always legal to provide a callback that accepts fewer arguments.
        
-
        Do write callback parameters as non-optional:
        
-
        /* OK */
+
        이는 아주 구체적인 의미를 가지고 있습니다: done 콜백은 1개 혹은 2개의 인자로 호출될 수 있습니다.
+작성자는 아마 elapsedTime 매개변수가 콜백에 상관없다는 것을 말하려는 의도였을 것입니다,
+  하지만 이를 위해 매개변수를 선택적으로 만들 필요는 없습니다 --
+  콜백에 더 적은 인수를 제공하는 것은 항상 허용됩니다.
        
+
        콜백 매개변수를 비-선택적으로 작성하세요:
        
+
        /* 좋음 */
 interface Fetcher {
     getObject(done: (data: any, elapsedTime: number) => void): void;
 }
 
        
-
        Overloads and Callbacks
        
-
        Don't write separate overloads that differ only on callback arity:
        
-
        /* WRONG */
+
        오버로드와 콜백 (Overloads and Callbacks)
        
+
        콜백의 인수만 다른 오버로드를 분리해서 작성 하지 마세요:
        
+
        /* 잘못됨 */
 declare function beforeAll(action: () => void, timeout?: number): void;
 declare function beforeAll(action: (done: DoneFn) => void, timeout?: number): void;
 
        
-
        Do write a single overload using the maximum arity:
        
-
        /* OK */
+
        최대 인수를 사용해 하나의 오버로드를 작성 하세요:
        
+
        /* 좋음 */
 declare function beforeAll(action: (done: DoneFn) => void, timeout?: number): void;
 
        
-
        Why: It's always legal for a callback to disregard a parameter, so there's no need for the shorter overload.
-Providing a shorter callback first allows incorrectly-typed functions to be passed in because they match the first overload.
        
-
        Function Overloads
        
-
        Ordering
        
-
        Don't put more general overloads before more specific overloads:
        
-
        /* WRONG */
+
        이유: 콜백이 매개변수를 무시하는 것은 항상 허용되므로, 짧은 오버로드는 필요하지 않습니다.
+더 짧은 콜백을 먼저 작성하면 넘어오는 함수가 첫 번째 오버로드와 일치하기 때문에 잘못된-타입의 함수를 허용합니다.
        
+
        함수 오버로드 (Function Overloads)
        
+
        순서 (Ordering)
        
+
        더 일반적인 오버로드를 더 구체적인 오버로드 이전에 두지 마세요:
        
+
        /* 잘못됨 */
 declare function fn(x: any): any;
 declare function fn(x: HTMLElement): number;
 declare function fn(x: HTMLDivElement): string;
@@ -788,8 +833,8 @@ 
        Ordering
        
 var myElem: HTMLDivElement;
 var x = fn(myElem); // x: any, wat?
 
        
-
        Do sort overloads by putting the more general signatures after more specific signatures:
        
-
        /* OK */
+
        구체적인 오버로드 뒤에 일반적인 오버로드가 위치하게 정렬 하세요:
        
+
        /* 좋음 */
 declare function fn(x: HTMLDivElement): string;
 declare function fn(x: HTMLElement): number;
 declare function fn(x: any): any;
@@ -797,65 +842,65 @@ 
        Ordering
        
 var myElem: HTMLDivElement;
 var x = fn(myElem); // x: string, :)
 
        
-
        Why: TypeScript chooses the first matching overload when resolving function calls.
-When an earlier overload is "more general" than a later one, the later one is effectively hidden and cannot be called.
        
-
        Use Optional Parameters
        
-
        Don't write several overloads that differ only in trailing parameters:
        
-
        /* WRONG */
+
        이유: TypeScript는 함수 호출을 처리할 때 첫 번째로 일치하는 오버로드를 선택합니다.
+이전의 오버로드가 뒤에 것보다 "더 구체적"이면, 뒤에 것은 사실상 가려져 호출되지 않습니다.
        
+
        선택적 매개변수 사용 (Use Optional Parameters)
        
+
        뒤따라오는 매개변수만 다른 오버로드를 작성하지 마세요:
        
+
        /* 잘못됨 */
 interface Example {
     diff(one: string): number;
     diff(one: string, two: string): number;
     diff(one: string, two: string, three: boolean): number;
 }
 
        
-
        Do use optional parameters whenever possible:
        
-
        /* OK */
+
        가능한 선택적 매개변수를 사용 하세요:
        
+
        /* 좋음 */
 interface Example {
     diff(one: string, two?: string, three?: boolean): number;
 }
 
        
-
        Note that this collapsing should only occur when all overloads have the same return type.
        
-
        Why: This is important for two reasons.
        
-
        TypeScript resolves signature compatibility by seeing if any signature of the target can be invoked with the arguments of the source,
-  and extraneous arguments are allowed.
-This code, for example, exposes a bug only when the signature is correctly written using optional parameters:
        
+
        이 문제는 모든 오버로드가 같은 반환 타입을 가질 때만 발생한다는 점에 유의하세요.
        
+
        이유: 두 가지 중요한 이유가 있습니다.
        
+
        TypeScript는 소스의 인수로 대상의 시그니처를 호출할 수 있는지 확인하여 시그니처 호환성을 결정합니다.
+  그리고 관계없는 인수가 허용됩니다
+예를 들어, 이 코드는 선택적 매개변수를 사용하여 올바르게 작성된 경우에만 버그를 노출합니다:
        
 
        function fn(x: (a: string, b: number, c: number) => void) { }
 var x: Example;
-// When written with overloads, OK -- used first overload
-// When written with optionals, correctly an error
+// 오버로드로 작성한 경우, OK -- 첫번째 오버로드가 사용됨
+// 선택적으로 작성한 경우, 올바르게 오류.
 fn(x.diff);
 
        
-
        The second reason is when a consumer uses the "strict null checking" feature of TypeScript.
-Because unspecified parameters appear as undefined in JavaScript, it's usually fine to pass an explicit undefined to a function with optional arguments.
-This code, for example, should be OK under strict nulls:
        
+
        두 번째 이유는 사용자가 TypeScript의 "strict null checking" 기능을 사용할 때입니다.
+JavaScript에서 지정되지 않은 매개변수는 undefined로 나타나기 때문에, 일반적으로 선택적 매개변수가 있는 함수에 명시적으로 undefined를 전달하는 것이 좋습니다.
+예를 들어, 이 코드는, strict null에서 문제없습니다.
        
 
        var x: Example;
-// When written with overloads, incorrectly an error because of passing 'undefined' to 'string'
-// When written with optionals, correctly OK
+// 오버로드로 작성한 경우, `undefined`를 `string` 에 전달했기 때문에 잘못된 에러
+// 선택적으로 작성한 경우, 올바름
 x.diff("something", true ? undefined : "hour");
 
        
-
        Use Union Types
        
-
        Don't write overloads that differ by type in only one argument position:
        
-
        /* WRONG */
+
        유니언 타입 사용 (Use Union Types)
        
+
        한 인수 위치에서 타입만 다른 오버로드를 사용하지 마세요:
        
+
        /* 잘못됨 */
 interface Moment {
     utcOffset(): number;
     utcOffset(b: number): Moment;
     utcOffset(b: string): Moment;
 }
 
        
-
        Do use union types whenever possible:
        
-
        /* OK */
+
        가능한 유니언 타입을 사용 하세요:
        
+
        /* 좋음 */
 interface Moment {
     utcOffset(): number;
     utcOffset(b: number|string): Moment;
 }
 
        
-
        Note that we didn't make b optional here because the return types of the signatures differ.
        
-
        Why: This is important for people who are "passing through" a value to your function:
        
+
        시그니처의 반환 타입이 다르기 때문에 b를 선택적으로 만들지 않은 점에 유의하세요.
        
+
        이유: 이는 함수에 값을 "전달하는" 사람들에게 중요합니다.:
        
 
        function fn(x: string): void;
 function fn(x: number): void;
 function fn(x: number|string) {
-    // When written with separate overloads, incorrectly an error
-    // When written with union types, correctly OK
+    // 분리된 오버로드로 작성된 경우, 잘못된 에러
+    // 유니언 타입으로 작성된 경우, 올바름
     return moment().utcOffset(x);
 }
 
        
@@ -902,7 +947,7 @@ 
        No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Do's and Don'ts","level":"4.4","depth":1,"next":{"title":"Deep Dive","level":"4.5","depth":1,"path":"pages/declaration files/Deep Dive.md","ref":"pages/declaration files/Deep Dive.md","articles":[]},"previous":{"title":"By Example","level":"4.3","depth":1,"path":"pages/declaration files/By Example.md","ref":"pages/declaration files/By Example.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/declaration files/Do's and Don'ts.md","mtime":"2019-06-14T05:32:52.254Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"../..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Do's and Don'ts","level":"4.4","depth":1,"next":{"title":"Deep Dive","level":"4.5","depth":1,"path":"pages/declaration files/Deep Dive.md","ref":"pages/declaration files/Deep Dive.md","articles":[]},"previous":{"title":"By Example","level":"4.3","depth":1,"path":"pages/declaration files/By Example.md","ref":"pages/declaration files/By Example.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/declaration files/Do's and Don'ts.md","mtime":"2020-04-22T15:29:36.182Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"../..","book":{"language":""}});
         });
     
 
diff --git a/pages/declaration files/Introduction.html b/pages/declaration files/Introduction.html
index 80a2ff56..0a672873 100644
--- a/pages/declaration files/Introduction.html	
+++ b/pages/declaration files/Introduction.html	
@@ -76,7 +76,7 @@
     
     
     
-    
+    
     
 
     
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
      • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
        • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
      • 
+        
      • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
        • 
+    
+        
      • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
        • 
     
-        
      • 
+        
      • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
        • 
     
-        
      • 
+        
      • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
      • 릴리즈 노트
        • 
+        
+        
+    
+        
      • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
        • 
+    
+
+    
 
     
      • 
 
@@ -711,29 +757,38 @@ 
        
     
                                 
        
                                 
-                                
        이 가이드는 높은 품질의 TypeScript 선언 파일을 작성하는 방법을 설명하기 위해 작성되었습니다.
        
-
        이 가이드에서는 TypeScript 언어에 대해 기본적인 지식을 전제로 합니다.
        아직 읽어 보지 않으셨다면 특히 타입과 네임스페이스와 같은 기본 개념에 
-익숙해지게 하도록 하기 위해 TypeScript 핸드북을 읽어 보시길 바랍니다. 
        
-
        섹션
        
-
        가이드는 다음 섹션으로 나뉩니다.
        
-
        라이브러리 구조
        
-
        라이브러리 구조 가이드는 일반적인 라이브러리 포맷과 각 포맷에 맞는 선언 파일을 작성하는 방법을 이해할 수 있도록 도와줍니다.
        기존 파일을 편집하는 경우에는 이 섹션을 읽지 않아도 됩니다.
        새로운 선언 파일의 작성자는 라이브러리 포맷이 선언 파일의 작성에 어떤 영향을 미치는지를 제대로 이해하기 위해 이 섹션을 읽어야 합니다.
        
-
        예제
        
-
        대부분, 사용자는 사용자를 안내해 줄 기본적인 라이브러리의 예만 있을 때 선언 파일을 작성하는 것에 직면하게 됩니다.
        예제 섹션에서는 많은 공통 API 패턴과 각각에 대한 선언을 작성하는 방법을 보여줍니다.
        이 가이드는 아직 TypeScript의 모든 언어 구조에 익숙하지 않을 수 있는 TypeScript 초보자를 대상으로 합니다.
        
-
        "하세요"와 "하지 마세요"
        
-
        선언 파일에서 자주 범하는 실수를 쉽게 피할 수 있습니다.
        "하세요"와 "하지 마세요" 섹션에서는 일반적인 오류를 식별합니다,
-  그것들을 감지하는 방법을 기술하고,
-  어떻게 고쳐야하는지.
-모든 사용자들은 일반적인 실수를 피하고자 이 섹션을 읽어야합니다.
        
-
        더 깊숙이
        
-
        선언 파일이 어떻게 작동하는지에 대한 기본 메커니즘에 관심이 있는 숙련자들을 위해,
-  더 깊숙이 섹션은 선언 작성의 많은 고급 개념을 설명하고 이러한 개념을 활용하여보다 명확하고 직관적인 선언 파일을 작성하는 방법을 설명합니다.
        
-
        템플릿
        
-
        템플릿에서 새 파일을 작성할 때 유용한 시작점이 되는 여러 선언 파일이 있습니다.
        어떤 템플릿 파일을 사용할 지 알아 보려면 라이브러리 구조의 문서를 참조하세요.
        
-
        npm 배포
        
-
        배포 섹션에서는 선언 파일을 npm 패키지에 배포하는 방법과 의존성 패키지를 관리하는 방법을 설명합니다.
        
-
        선언 파일 찾기와 설치
        
-
        JavaScript 라이브러리 사용자의 경우 Consumption 섹션에서 해당 선언 파일을 찾아 설치하는 몇 가지 간단한 단계를 제공합니다.
        
+                                
        이 가이드는 고품질의 TypeScript 선언 파일을 작성하는 방법을 알려주기 위해 작성되었습니다.
        
+
        이 가이드는, TypeScript 언어에 대한 기본 지식이 있다고 가정합니다.
+만약 기본 지식이 없다면, TypeScript 핸드북을 반드시 읽고
+  기본 개념, 특히 타입과 네임스페이스에 익숙해져야 합니다.
        
+
        섹션 (Sections)
        
+
        이 가이드는 다음 섹션들로 구성됩니다.
        
+
        라이브러리 구조 (Library Structures)
        
+
        라이브러리 구조는 일반적인 라이브러리 포맷과 각 포맷에 대한 올바른 선언 파일을 작성하는 방법에 대해 알려줍니다.
+기존 파일을 수정하는 경우라면, 이 섹션을 읽으실 필요는 없습니다.
+새로운 선언 파일을 작성해야 한다면 라이브러리의 포맷이 선언 파일 작성에 어떻게 영향을 미치는지 올바르게 이해하기 위해 반드시 읽어야 합니다.
        
+
        예제를 통해 (By Example)
        
+
        많은 경우, 기본 라이브러리 예제만 있을 때, 선언 파일을 작성해야 합니다.
+예제를 통해 섹션은 많은 API 패턴들과 각 패턴들의 선언을 작성하는 방법을 보여줍니다.
+이 가이드는 TypeScript의 모든 언어 구성에 아직 익숙하지 않은 TypeScript 초심자에 초점을 맞추고 있습니다.
        
+
        해야 할 것과 하지 말아야 할 것 ("Do"s and "Don't"s)
        
+
        선언 파일의 많은 실수들은 쉽게 피할 수 있습니다.
+해야 할 것과 하지 말아야 할 것 섹션은 흔한 오류들을 식별하고,
+  감지하는 방법과,
+  수정하는 방법을 설명합니다.
+흔한 실수들을 피하기 위해 반드시 모두가 이 섹션을 읽어야 합니다.
        
+
        깊게 들어가기 (Deep Dive)
        
+
        선언 파일이 동작하는 메커니즘에 관심 있는 숙련된 사용자들에게,
+  깊게 들어가기 섹션은 선언 작성의 많은 고급 개념을 설명해 주고,
+  이 개념들을 활용하여 깔끔하고 더 직관적인 선언 파일을 만드는 방법을 보여줍니다.
        
+
        템플릿 (Templates)
        
+
        템플릿에서는 새로운 파일을 작성할 때, 유용한 시작점을 제공하는
+  여러 선언 파일들을 찾을 수 있습니다.
+라이브러리 구조 문서를 참고하여 어떤 템플릿 파일을 사용할지 알아보세요.
        
+
        npm에 배포하기 (Publish to npm)
        
+
        배포 섹션은 선언 파일을 npm 패키지에 배포하는 방법과, 의존성 패키지를 관리하는 방법을 설명합니다.
        
+
        선언 파일을 찾고 설치하기 (Find and Install Declaration Files)
        
+
        JavaScript 라이브러리 사용자를 위해, 소비 섹션은 해당 선언 파일을 찾고 설치하는 몇 가지 간단한 방법을 제공합니다.
        
 
                                 
                                 
        
@@ -761,7 +816,7 @@ 
        No results matching "
+                
                     
                 
                 
@@ -777,7 +832,7 @@ 
        No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"소개","level":"4.1","depth":1,"next":{"title":"Library Structures","level":"4.2","depth":1,"path":"pages/declaration files/Library Structures.md","ref":"pages/declaration files/Library Structures.md","articles":[]},"previous":{"title":"JavaScript 파일 타입 검사","level":"3.22","depth":1,"path":"pages/Type Checking JavaScript Files.md","ref":"pages/Type Checking JavaScript Files.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/declaration files/Introduction.md","mtime":"2019-06-14T05:32:52.254Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"../..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"소개","level":"4.1","depth":1,"next":{"title":"Library Structures","level":"4.2","depth":1,"path":"pages/declaration files/Library Structures.md","ref":"pages/declaration files/Library Structures.md","articles":[]},"previous":{"title":"유틸리티 타입","level":"3.23","depth":1,"path":"pages/Utility Types.md","ref":"pages/Utility Types.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/declaration files/Introduction.md","mtime":"2020-04-22T15:29:36.182Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"../..","book":{"language":""}});
         });
     
 
diff --git a/pages/declaration files/Library Structures.html b/pages/declaration files/Library Structures.html
index 92d9cd9f..bd0a2129 100644
--- a/pages/declaration files/Library Structures.html	
+++ b/pages/declaration files/Library Structures.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
      • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
        • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
      • 
+        
      • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
        • 
+    
+        
      • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
        • 
     
-        
      • 
+        
      • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
        • 
     
-        
      • 
+        
      • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
      • 릴리즈 노트
        • 
+        
+        
+    
+        
      • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
        • 
+    
+
+    
 
     
      • 
 
@@ -711,107 +757,107 @@ 
        
     
                                 
        
                                 
-                                
        Overview
        
-
        Broadly speaking, the way you structure your declaration file depends on how the library is consumed.
-There are many ways of offering a library for consumption in JavaScript, and you'll need to write your declaration file to match it.
-This guide covers how to identify common library patterns, and how to write declaration files which correspond to that pattern.
        
-
        Each type of major library structuring pattern has a corresponding file in the Templates section.
-You can start with these templates to help you get going faster.
        
-
        Identifying Kinds of Libraries
        
-
        First, we'll review the kinds of libraries TypeScript declaration files can represent.
-We'll briefly show how each kind of library is used, how it is written, and list some example libraries from the real world.
        
-
        Identifying the structure of a library is the first step in writing its declaration file.
-We'll give hints on how to identify structure both based on its usage and its code.
-Depending on the library's documentation and organization, one might be easier than the other.
-We recommend using whichever is more comfortable to you.
        
-
        Global Libraries
        
-
        A global library is one that can be accessed from the global scope (i.e. without using any form of import).
-Many libraries simply expose one or more global variables for use.
-For example, if you were using jQuery, the $ variable can be used by simply referring to it:
        
+                                
        개요 (Overview)
        
+
        일반적으로, 선언 파일을 구조화하는 방법은 라이브러리를 사용하는 방법에 따라 다릅니다.
+JavaScript에서 사용할 라이브러리를 제공하는 방법은 여러 가지가 있고, 이에 맞추어 선언 파일을 작성해야 합니다.
+이 가이드는 일반적인 라이브러리 패턴을 식별하는 방법과, 그 패턴에 상응하는 선언 파일을 작성하는 방법에 대해 다룹니다.
        
+
        주요 라이브러리 각각의 구조화 패턴 유형은 템플릿 섹션에 있습니다.
+이 템플릿으로 시작하면 더 빠르게 진행할 수 있습니다.
        
+
        라이브러리 종류 식별하기 (Identifying Kinds of Libraries)
        
+
        첫 번째로, TypeScript 선언 파일이 나타낼 수 있는 라이브러리 종류를 다뤄보겠습니다.
+각 종류의 라이브러리를 사용하는 방법과, 작성하는 방법, 그리고 실제 라이브러리들의 예제를 볼 것입니다.
        
+
        라이브러리의 구조를 식별하는 것은 선언 파일을 작성하는 첫 단계입니다.
+사용법과 코드를 기반으로 구조를 식별하는 방법에 대한 힌트를 제공합니다.
+라이브러리의 문서와 구성에 따라서, 어떤 건 다른 것보다 훨씬 쉬울 수 있습니다.
+본인에게 더 편한 것을 사용할 것을 추천합니다.
        
+
        전역 라이브러리 (Global Libraries)
        
+
        전역 라이브러리는 전역 스코프 (즉, import 형식을 사용하지 않음)에서 접근 가능한 라이브러리입니다.
+많은 라이브러리는 사용을 위해 간단히 하나 이상의 전역 변수를 노출합니다.
+예를 들어, jQuery를 사용한다면, $ 변수를 참조해서 사용할 수 있습니다:
        
 
        $(() => { console.log('hello!'); } );
 
        
-
        You'll usually see guidance in the documentation of a global library of how to use the library in an HTML script tag:
        
+
        HTML 스크립트 태그로 라이브러리를 사용하는 방법은 라이브러리 문서에서 지침을 볼 수 있습니다:
        
 
        <script src="http://a.great.cdn.for/someLib.js"></script>
 
        
-
        Today, most popular globally-accessible libraries are actually written as UMD libraries (see below).
-UMD library documentation is hard to distinguish from global library documentation.
-Before writing a global declaration file, make sure the library isn't actually UMD.
        
-
        Identifying a Global Library from Code
        
-
        Global library code is usually extremely simple.
-A global "Hello, world" library might look like this:
        
+
        오늘날, 대부분의 전역에서 접근 가능한 유명 라이브러리들은 실제로 UMD 라이브러리로 작성되어 있습니다 (아래를 참조).
+UMD 라이브러리 문서는 전역 라이브러리 문서와 구별하기 어렵습니다.
+전역 선언 파일을 작성하기 전에, 실제로는 UMD가 아닌지 확인하십시오.
        
+
        코드에서 전역 라이브러리 식별하기 (Identifying a Global Library from Code)
        
+
        전역 라이브러리 코드는 대게 엄청 간단합니다.
+전역 "Hello, world" 라이브러리는 다음과 같습니다:
        
 
        function createGreeting(s) {
     return "Hello, " + s;
 }
 
        
-
        or like this:
        
+
        혹은 다음과 같습니다:
        
 
        window.createGreeting = function(s) {
     return "Hello, " + s;
 }
 
        
-
        When looking at the code of a global library, you'll usually see:
        
+
        전역 라이브러리의 코드를 보면, 보통 다음을 볼 수 있습니다:
        
 
          
-
        • Top-level var statements or function declarations
          • 
-
        • One or more assignments to window.someName
          • 
-
        • Assumptions that DOM primitives like document or window exist
          • 
+
        • 최상위 레벨 var문 이나 function선언
          • 
+
        • 하나 이상의 window.someName 할당
          • 
+
        • DOM 인터페이스 document 혹은 window가 존재한다고 가정
          • 
 
        
-
        You won't see:
        
+
        다음은 볼 수 없습니다:
        
 
          
-
        • Checks for, or usage of, module loaders like require or define
          • 
-
        • CommonJS/Node.js-style imports of the form var fs = require("fs");
          • 
-
        • Calls to define(...)
          • 
-
        • Documentation describing how to require or import the library
          • 
+
        • require 이나 define 같은 모듈 로더 검사 혹은 사용
          • 
+
        • var fs = require("fs"); 형태의 CommonJS/Node.js-스타일 import
          • 
+
        • define(...) 호출
          • 
+
        • 라이브러리를 require 혹은 import하는 방법에 대해 설명하는 문서
          • 
 
        
-
        Examples of Global Libraries
        
-
        Because it's usually easy to turn a global library into a UMD library, very few popular libraries are still written in the global style.
-However, libraries that are small and require the DOM (or have no dependencies) may still be global.
        
-
        Global Library Template
        
-
        The template file global.d.ts defines an example library myLib.
-Be sure to read the "Preventing Name Conflicts" footnote.
        
-
        Modular Libraries
        
-
        Some libraries only work in a module loader environment.
-For example, because express only works in Node.js and must be loaded using the CommonJS require function.
        
-
        ECMAScript 2015 (also known as ES2015, ECMAScript 6, and ES6), CommonJS, and RequireJS have similar notions of importing a module.
-In JavaScript CommonJS (Node.js), for example, you would write
        
-
        var fs = require("fs");
+
        전역 라이브러리 예제 (Examples of Global Libraries)
        
+
        전역 라이브러리를 UMD 라이브러리로 바꾸는게 쉽기 때문에, 전역 스타일로 작성한 인기 라이브러리는 거의 없습니다.
+하지만, 크기가 작고 DOM이 필요한 (혹은 의존성이 없는) 라이브러리는 여전히 전역입니다.
        
+
        전역 라이브러리 템플릿 (Global Library Template)
        
+
        템플릿 파일 global.d.ts은 예제 라이브러리 myLib를 정의합니다.
+"이름 충돌 방지" 각주를 반드시 읽어보세요.
        
+
        모듈형 라이브러리 (Modular Libraries)
        
+
        어떤 라이브러리는 모듈 로더 환경에서만 동작합니다.
+예를 들어, express는 Node.js에서만 동작하고 반드시 CommonJS의 require 함수로 로드되어야 합니다.
        
+
        ECMAScript 2015 (ES2015, ECMAScript 6, ES6로도 잘 알려진), CommonJS와 RequireJS는 모듈을 importing하는 비슷한 개념을 가지고 있습니다.
+JavaScript의 CommonJS (Node.js)를 예를 들면, 다음과 같이 작성합니다
        
+
        var fs = require("fs");
 
        
-
        In TypeScript or ES6, the import keyword serves the same purpose:
        
+
        TypeScript나 ES6에서는, import 키워드가 같은 목적을 제공합니다:
        
 
        import fs = require("fs");
 
        
-
        You'll typically see modular libraries include one of these lines in their documentation:
        
+
        일반적으로 모듈형 라이브러리의 문서에서 다음 코드들 중 하나를 볼 수 있습니다:
        
 
        var someLib = require('someLib');
 
        
-
        or
        
-
        define(..., ['someLib'], function(someLib) {
+
        혹은
        
+
        define(..., ['someLib'], function(someLib) {
 
 });
 
        
-
        As with global modules, you might see these examples in the documentation of a UMD module, so be sure to check the code or documentation.
        
-
        Identifying a Module Library from Code
        
-
        Modular libraries will typically have at least some of the following:
        
+
        전역 모듈과 마찬가지로 UMD 모듈의 문서에서도 이 예제들을 볼 수 있으므로, 코드나 문서를 반드시 확인하세요.
        
+
        코드에서 모듈 라이브러리 식별하기 (Identifying a Module Library from Code)
        
+
        모듈형 라이브러리는 일반적으로 다음 중 몇 가지를 반드시 가지고 있습니다:
        
 
          
-
        • Unconditional calls to require or define
          • 
-
        • Declarations like import * as a from 'b'; or export c;
          • 
-
        • Assignments to exports or module.exports
          • 
+
        • require 혹은 define에 대한 무조건적인 호출
          • 
+
        • import * as a from 'b'; 혹은 export c; 같은 선언문
          • 
+
        • exports 혹은 module.exports에 대한 할당
          • 
 
        
-
        They will rarely have:
        
+
        다음은 거의 갖지 않습니다:
        
 
          
-
        • Assignments to properties of window or global
          • 
+
        • window 혹은 global 프로퍼티 할당
          • 
 
        
-
        Examples of Modular Libraries
        
-
        Many popular Node.js libraries are in the module family, such as express, gulp, and request.
        
+
        모듈형 라이브러리 예제 (Examples of Modular Libraries)
        
+
        많은 유명한 Node.js 라이브러리들은 express, gulp, request와 같은 모듈군 안에 있습니다.
        
 
        UMD
        
-
        A UMD module is one that can either be used as module (through an import), or as a global (when run in an environment without a module loader).
-Many popular libraries, such as Moment.js, are written this way.
-For example, in Node.js or using RequireJS, you would write:
        
+
        UMD 모듈은 모듈로 (import를 통해) 사용할 수 있고 혹은 전역으로도 (모듈 로더 없는 환경에서 실행될 때) 사용할 수 있습니다.
+Moment.js 같은 많은 유명한 라이브러리들은 이 방법으로 작성되었습니다.
+예를 들어, Node.js나 RequireJS를 사용하면, 다음과 같이 작성합니다:
        
 
        import moment = require("moment");
 console.log(moment.format());
 
        
-
        whereas in a vanilla browser environment you would write:
        
-
        console.log(moment.format());
+
        반면 바닐라 브라우저 환경에서는 다음과 같이 쓸 수 있습니다:
        
+
        console.log(moment.format());
 
        
-
        Identifying a UMD library
        
-
        UMD modules check for the existence of a module loader environment.
-This is an easy-to-spot pattern that looks something like this:
        
+
        UMD 라이브러리 식별하기 (Identifying a UMD library)
        
+
        UMD modules은 모듈 로더 환경 유무를 검사합니다.
+이는 다음과 같이 보이는 찾기 쉬운 패턴입니다:
        
 
        (function (root, factory) {
     if (typeof define === "function" && define.amd) {
         define(["libName"], factory);
@@ -822,130 +868,155 @@ 
        Identifying a UMD library
        
     }
 }(this, function (b) {
 
        
-
        If you see tests for typeof define, typeof window, or typeof module in the code of a library, especially at the top of the file, it's almost always a UMD library.
        
-
        Documentation for UMD libraries will also often demonstrate a "Using in Node.js" example showing require,
-  and a "Using in the browser" example showing using a <script> tag to load the script.
        
-
        Examples of UMD libraries
        
-
        Most popular libraries are now available as UMD packages.
-Examples include jQuery, Moment.js, lodash, and many more.
        
-
        Template
        
-
        There are three templates available for modules,
-  module.d.ts, module-class.d.ts and module-function.d.ts.
        
-
        Use module-function.d.ts if your module can be called like a function:
        
-
        var x = require("foo");
-// Note: calling 'x' as a function
+
        만약 라이브러리 코드, 특히 파일 상단에서 typeof define, typeof window 혹은 typeof module에 대한 테스트를 보았다면, 거의 대부분 UMD 라이브러리입니다.
        
+
        UMD 라이브러리 문서에서는 require를 보여주는 "Node.js에서 사용하기" 예제를 종종 설명하고
+  "브라우저에서 사용하기" 예제에서는 <script> 태그를 사용해서 스크립트를 로드하는 방법을 보여줍니다.
        
+
        UMD 라이브러리 예제 (Examples of UMD libraries)
        
+
        유명한 라이브러리 대부분은 UMD 패키지로 사용할 수 있습니다.
+예로는 jQuery, Moment.js, loadash 등 더 많이 있습니다.
        
+
        템플릿 (Template)
        
+
        모듈은 세 가지 템플릿을 사용할 수 있습니다,
+  module.d.ts, module-class.d.ts 그리고 module-function.d.ts.
        
+
        만약 모듈을 함수처럼 호출할 수 있으면 module-function.d.ts을 사용하세요:
        
+
        var x = require("foo");
+// 참고: 함수로 'x'를 호출
 var y = x(42);
 
        
-
        Be sure to read the footnote "The Impact of ES6 on Module Call Signatures"
        
-
        Use module-class.d.ts if your module can be constructed using new:
        
-
        var x = require("bar");
-// Note: using 'new' operator on the imported variable
+
        각주 "ES6가 모듈 호출 시그니처에 미치는 영향"를 반드시 읽어보세요
        
+
        만약 모듈이 new를 사용하여 생성할 수 있다면 module-class.d.ts를 사용하세요:
        
+
        var x = require("bar");
+// 참고: 'new' 연산자를 import된 변수에 사용
 var y = new x("hello");
 
        
-
        The same footnote applies to these modules.
        
-
        If your module is not callable or constructable, use the module.d.ts file.
        
-
        Module Plugin or UMD Plugin
        
-
        A module plugin changes the shape of another module (either UMD or module).
-For example, in Moment.js, moment-range adds a new range method to the moment object.
        
-
        For the purposes of writing a declaration file, you'll write the same code whether the module being changed is a plain module or UMD module.
        
-
        Template
        
-
        Use the module-plugin.d.ts template.
        
-
        Global Plugin
        
-
        A global plugin is global code that changes the shape of some global.
-As with global-modifying modules, these raise the possibility of runtime conflict.
        
-
        For example, some libraries add new functions to Array.prototype or String.prototype.
        
-
        Identifying global plugins
        
-
        Global plugins are generally easy to identify from their documentation.
        
-
        You'll see examples that look like this:
        
-
        var x = "hello, world";
-// Creates new methods on built-in types
+
        이런 모듈에도 같은 각주가 적용됩니다.
        
+
        만약 모듈이 위 사항에 해당되지 않다면, module.d.ts 파일을 사용하세요.
        
+
        모듈 플러그인 혹은 UMD 플러그인 (Module Plugin or UMD Plugin)
        
+
        모듈 플러그인은 다른 모듈 (UMD나 모듈)의 형태를 변경합니다.
+예를 들어, Moment.js에서, moment-range는 moment 객체에 새로운 range 메서드를 추가합니다.
        
+
        선언 파일 작성을 위해, 모듈이 일반 모듈로 변경되든 UMD 모듈로 변경되든 같은 코드를 작성합니다.
        
+
        템플릿 (Template)
        
+
        module-plugin.d.ts 템플릿을 사용하세요.
        
+
        전역 플러그인 (Global Plugin)
        
+
        전역 플러그인은 전역의 형태를 변경하는 전역 코드입니다.
+전역-수정 모듈과 마찬가지로 런타임에 충돌 가능성을 높입니다.
        
+
        예를 들어, 몇몇 라이브러리는 Array.prototype이나 String.prototype에 새로운 함수를 추가합니다.
        
+
        전역 플러그인 식별하기 (Identifying global plugins)
        
+
        전역 플러그인은 일반적으로 문서를 보고 쉽게 식별할 수 있습니다.
        
+
        다음과 같은 예제를 볼 수 있습니다:
        
+
        var x = "hello, world";
+// 내장 타입에 새로운 메서드 생성
 console.log(x.startsWithHello());
 
 var y = [1, 2, 3];
-// Creates new methods on built-in types
+// 내장 타입에 새로운 메서드 생성
 console.log(y.reverseAndSort());
 
        
-
        Template
        
-
        Use the global-plugin.d.ts template.
        
-
        Global-modifying Modules
        
-
        A global-modifying module alters existing values in the global scope when they are imported.
-For example, there might exist a library which adds new members to String.prototype when imported.
-This pattern is somewhat dangerous due to the possibility of runtime conflicts,
-  but we can still write a declaration file for it.
        
-
        Identifying global-modifying modules
        
-
        Global-modifying modules are generally easy to identify from their documentation.
-In general, they're similar to global plugins, but need a require call to activate their effects.
        
-
        You might see documentation like this:
        
-
        // 'require' call that doesn't use its return value
+
        템플릿 (Template)
        
+
        global-plugin.d.ts 템플릿을 사용하세요.
        
+
        전역-수정 모듈 (Global-modifying Modules)
        
+
        전역-수정 모듈은 import 될 때, 전역 스코프에 존재하는 값을 변경합니다.
+예를 들어, import 될 때 String.prototype에 새로운 멤버를 추가하는 라이브러리가 있을 수 있습니다.
+이 패턴은 런타임 충돌의 가능성 때문에 위험하지만,
+  여전히 선언 파일을 작성할 수 있습니다.
        
+
        전역-수정 모듈 식별하기 (Identifying global-modifying modules)
        
+
        전역-수정 모듈은 일반적으로 문서를 보고 쉽게 식별할 수 있습니다.
+일반적으로, 전역 플러그인과 비슷하지만, 효과를 활성화하기 위해 require 호출이 필요합니다.
        
+
        다음과 같은 문서를 볼 수 있습니다:
        
+
        // 반환값을 사용하지 않는 'require' 호출
 var unused = require("magic-string-time");
-/* or */
+/* 혹은 */
 require("magic-string-time");
 
 var x = "hello, world";
-// Creates new methods on built-in types
+// 내장 타입에 새로운 메서드 생성
 console.log(x.startsWithHello());
 
 var y = [1, 2, 3];
-// Creates new methods on built-in types
+// 내장 타입에 새로운 메서드 생성
 console.log(y.reverseAndSort());
 
        
-
        Template
        
-
        Use the global-modifying-module.d.ts template.
        
-
        Consuming Dependencies
        
-
        There are several kinds of dependencies you might have.
        
-
        Dependencies on Global Libraries
        
-
        If your library depends on a global library, use a /// <reference types="..." /> directive:
        
+
        템플릿 (Template)
        
+
        global-modifying-module.d.ts 템플릿을 사용하세요.
        
+
        의존성 사용하기 (Consuming Dependencies)
        
+
        라이브러리가 몇 가지 의존성을 가지고 있을 수 있습니다.
+이번 섹션에서는 선언 파일 안에 의존성을 import 하는 방법을 설명합니다.
        
+
        전역 라이브러리 의존성 (Dependencies on Global Libraries)
        
+
        만약 라이브러리가 전역 라이브러리에 의존성이 있다면, /// <reference types="..." /> 디렉티브를 사용하세요:
        
 
        /// <reference types="someLib" />
 
 function getThing(): someLib.thing;
 
        
-
        Dependencies on Modules
        
-
        If your library depends on a module, use an import statement:
        
+
        모듈 의존성 (Dependencies on Modules)
        
+
        만약 라이브러리가 모듈에 의존성이 있다면, import문을 사용하세요:
        
 
        import * as moment from "moment";
 
 function getThing(): moment;
 
        
-
        Dependencies on UMD libraries
        
-
        From a Global Library
        
-
        If your global library depends on a UMD module, use a /// <reference types directive:
        
+
        UMD 라이브러리 의존성 (Dependencies on UMD libraries)
        
+
        전역 라이브러리에서 (From a Global Library)
        
+
        만약 전역 라이브러리가 UMD 모듈에 의존성이 있다면, /// <reference types 디렉티브를 사용하세요:
        
 
        /// <reference types="moment" />
 
 function getThing(): moment;
 
        
-
        From a Module or UMD Library
        
-
        If your module or UMD library depends on a UMD library, use an import statement:
        
+
        모듈이나 UMD 라이브러리에서 (From a Module or UMD Library)
        
+
        만약 모듈이나 UMD 라이브러리가 UMD 라이브러리에 의존성이 있다면, import문을 사용하세요:
        
 
        import * as someLib from 'someLib';
 
        
-
        Do not use a /// <reference directive to declare a dependency to a UMD library!
        
-
        Footnotes
        
-
        Preventing Name Conflicts
        
-
        Note that it's possible to define many types in the global scope when writing a global declaration file.
-We strongly discourage this as it leads to possible unresolvable name conflicts when many declaration files are in a project.
        
-
        A simple rule to follow is to only declare types namespaced by whatever global variable the library defines.
-For example, if the library defines the global value 'cats', you should write
        
+
        UMD 라이브러리에 대한 의존성 선언에 /// <reference 디렉티브를 사용하지 마세요!
        
+
        각주 (Footnotes)
        
+
        이름 충돌 방지하기 (Preventing Name Conflicts)
        
+
        전역 선언 파일을 작성할 때, 전역 스코프에 많은 타입을 정의할 수 있다는 점을 유의하세요.
+많은 선언 파일이 프로젝트 내에 있을 때, 해결할 수 없는 이름 충돌이 발생할 수 있으므로 이를 사용하지 않는 것이 좋습니다.
        
+
        따라야 하는 간단한 규칙은 라이브러리가 정의한 전역 변수가 무엇이든 타입을 네임스페이스로 정의하는 것입니다.
+예를 들어, 만약 라이브러리가 전역 값 'cats'를 정의하면, 다음과 같이 작성하고
        
 
        declare namespace cats {
     interface KittySettings { }
 }
 
        
-
        But not
        
-
        // at top-level
+
        이렇게 하지는 마세요
        
+
        // 최상위-레벨에서
 interface CatsKittySettings { }
 
        
-
        This guidance also ensures that the library can be transitioned to UMD without breaking declaration file users.
        
-
        The Impact of ES6 on Module Plugins
        
-
        Some plugins add or modify top-level exports on existing modules.
-While this is legal in CommonJS and other loaders, ES6 modules are considered immutable and this pattern will not be possible.
-Because TypeScript is loader-agnostic, there is no compile-time enforcement of this policy, but developers intending to transition to an ES6 module loader should be aware of this.
        
-
        The Impact of ES6 on Module Call Signatures
        
-
        Many popular libraries, such as Express, expose themselves as a callable function when imported.
-For example, the typical Express usage looks like this:
        
+
        이 가이드는 선언 파일 사용자가 중단하지 않고 라이브러리를 UMD로 전환할 수 있도록 합니다.
        
+
        ES6가 모듈 플러그인에 미치는 영향 (The Impact of ES6 on Module Plugins)
        
+
        어떤 플러그인은 기존 모듈에 최상위 export를 추가하거나 수정합니다.
+CommonJS와 다른 로더에서는 허용되지만, ES6 모듈은 불변하다고 간주되기에 이 패턴은 불가능합니다.
+왜냐하면 TypeScript는 로더에 구애받지 않기에, 이 정책이 컴파일-시간에 적용되지 않지만, ES6 모듈 로더로 전환하려는 개발자는 알고 있어야 합니다.
        
+
        모듈 호출 시그니처에 ES6가 미치는 영향 (The Impact of ES6 on Module Call Signatures)
        
+
        Express와 같은 많은 유명한 라이브러리들은 import 될 때 호출 가능한 함수를 노출합니다.
+예를 들어, 일반적인 Express 사용법은 다음과 같습니다:
        
 
        import exp = require("express");
 var app = exp();
 
        
-
        In ES6 module loaders, the top-level object (here imported as exp) can only have properties;
-  the top-level module object is never callable.
-The most common solution here is to define a default export for a callable/constructable object;
-  some module loader shims will automatically detect this situation and replace the top-level object with the default export.
        
+
        ES6 모듈 로더에서, 최상위-레벨 객체(여기에서는 exp로 import)는 프로퍼티만 가질 수 있습니다;
+  최상위-레벨 모듈 객체는 절대 호출할 수 없습니다.
+가장 일반적인 해결책은 호출 가능/생성 가능 객체를 default export로 정의하는 것입니다;
+  어떤 모듈 로더 shims은 자동으로 이 상황을 감지하고 최상위-레벨 객체를 default export로 바꿉니다.
        
+
        라이브러리 파일 레이아웃 (Library file layout)
        
+
        선언 파일의 레이아웃은 라이브러리의 레이아웃을 반영해야 합니다.
        
+
        라이브러리는 다음과 같이 여러 모듈로 구성됩니다
        
+
        myLib
+  +---- index.js
+  +---- foo.js
+  +---- bar
+         +---- index.js
+         +---- baz.js
+
        
+
        이는 다음과 같이 import 할 수 있습니다
        
+
        var a = require("myLib");
+var b = require("myLib/foo");
+var c = require("myLib/bar");
+var d = require("myLib/bar/baz");
+
        
+
        그러므로 선언 파일은 다음과 같아야 합니다
        
+
        @types/myLib
+  +---- index.d.ts
+  +---- foo.d.ts
+  +---- bar
+         +---- index.d.ts
+         +---- baz.d.ts
+
        
 
                                 
                                 
        
@@ -989,7 +1060,7 @@ 
        No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Library Structures","level":"4.2","depth":1,"next":{"title":"By Example","level":"4.3","depth":1,"path":"pages/declaration files/By Example.md","ref":"pages/declaration files/By Example.md","articles":[]},"previous":{"title":"소개","level":"4.1","depth":1,"path":"pages/declaration files/Introduction.md","ref":"pages/declaration files/Introduction.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/declaration files/Library Structures.md","mtime":"2019-06-14T05:32:52.255Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"../..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Library Structures","level":"4.2","depth":1,"next":{"title":"By Example","level":"4.3","depth":1,"path":"pages/declaration files/By Example.md","ref":"pages/declaration files/By Example.md","articles":[]},"previous":{"title":"소개","level":"4.1","depth":1,"path":"pages/declaration files/Introduction.md","ref":"pages/declaration files/Introduction.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/declaration files/Library Structures.md","mtime":"2020-04-22T15:29:36.183Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"../..","book":{"language":""}});
         });
     
 
diff --git a/pages/declaration files/Publishing.html b/pages/declaration files/Publishing.html
index 7569b674..18fb3e8f 100644
--- a/pages/declaration files/Publishing.html	
+++ b/pages/declaration files/Publishing.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
      • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
        • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
      • 
+        
      • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
        • 
+    
+        
      • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
        • 
     
-        
      • 
+        
      • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
        • 
     
-        
      • 
+        
      • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
      • 릴리즈 노트
        • 
+        
+        
+    
+        
      • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
        • 
+    
+
+    
 
     
      • 
 
@@ -711,20 +757,20 @@ 
        
     
                                 
        
                                 
-                                
        Now that you have authored a declaration file following the steps of this guide, it is time to publish it to npm.
-There are two main ways you can publish your declaration files to npm:
        
+                                
        이 가이드를 따라 선언 파일을 작성했으므로, 이제 npm에 배포할 시간입니다.
+npm에 선언 파일을 배포하는 방법은 크게 두 가지가 있습니다:
        
 
          
-
        1. bundling with your npm package, or
          2. 
-
        2. publishing to the @types organization on npm.
          3. 
+
        3. npm 패키지로 번들링하거나
          4. 
+
        4. npm의 @types organization에 배포하기
          5. 
 
        
-
        If your package is written in TypeScript then the first approach is favored.
-Use the --declaration flag to generate declaration files.
-This way, your declarations and JavaScript always be in sync.
        
-
        If your package is not written in TypeScript then the second is the prefered approch.
        
-
        Including declarations in your npm package
        
-
        If your package has a main .js file, you will need to indicate the main declaration file in your package.json file as well.
-Set the types property to point to your bundled declaration file.
-For example:
        
+
        만약 패키지가 TypeScript로 작성되었다면 첫 번째 방법을 사용하는 것이 좋습니다.
+--declaration 플래그를 사용하여 선언 파일을 생성하세요.
+이 방법을 사용하면, 선언과 JavaScript가 항상 일치하게 됩니다.
        
+
        만약 패키지가 TypeScript로 작성되지 않았다면 두 번째 방법을 사용하는 것이 좋습니다.
        
+
        npm 패키지에 선언 포함하기 (Including declarations in your npm package)
        
+
        만약 패키지가 메인 .js 파일을 가지고 있다면, 메인 선언 파일을 package.json에도 표시해야 합니다.
+번들링된 선언 파일을 types 프로퍼티로 가리키도록 하세요.
+예를 들어:
        
 
        {
     "name": "awesome",
     "author": "Vandelay Industries",
@@ -733,12 +779,13 @@ 
        Including declarations in yo
     "types": "./lib/main.d.ts"
 }
 
        
-
        Note that the "typings" field is synonymous with "types", and could be used as well.
        
-
        Also note that if your main declaration file is named index.d.ts and lives at the root of the package (next to index.js) you do not need to mark the "types" property, though it is advisable to do so.
        
-
        Dependencies
        
-
        All dependencies are managed by npm.
-Make sure all the declaration packages you depend on are marked appropriately in the "dependencies" section in your package.json.
-For example, imagine we authored a package that used Browserify and TypeScript.
        
+
        "typings" 필드는 "types"와 동의어이기 때문에 역시 사용할 수 있습니다.
        
+
        또한 package.json이 "files" 프로퍼티를 포함하고 있으면 "types" 프로퍼티는 무시됩니다. 이 경우 메인 선언 파일을 "files" 프로퍼티에 전달해야 합니다.
        
+
        만약 메인 선언 파일 이름이 index.d.ts이고 패키지의 루트에 있으면 (index.js 옆에) "types" 프로퍼티를 쓰지 않아도 되지만, 쓰는 것이 좋습니다.
        
+
        의존성 (Dependencies)
        
+
        모든 의존성은 npm으로 관리됩니다.
+의존성이 있는 모든 선언 패키지가 package.json에 "dependencies" 섹션 안에 알맞게 작성되어 있는지 확인하세요.
+예를 들어, Browserify와 TypeScript로 작성된 패키지를 생각해봅시다.
        
 
        {
     "name": "browserify-typescript-extension",
     "author": "Vandelay Industries",
@@ -752,34 +799,34 @@ 
        Dependencies
        
     }
 }
 
        
-
        Here, our package depends on the browserify and typescript packages.
-browserify does not bundle its declaration files with its npm packages, so we needed to depend on @types/browserify for its declarations.
-typescript, on the other hand, packages its declaration files, so there was no need for any additional dependencies
        
-
        Our package exposes declarations from each of those, so any user of our browserify-typescript-extension package needs to have these dependencies as well.
-For that reason, we used "dependencies" and not "devDependencies", because otherwise our consumers would have needed to manually install those packages.
-If we had just written a command line application and not expected our package to be used as a library, we might have used devDependencies.
        
-
        Red flags
        
+
        여기에서, 패키지는 browserify와 typescript 패키지에 의존성이 있습니다.
+browserify는 선언 파일이 npm 패키지에 함께 번들링 되지 않기 때문에, @types/browserify 선언을 의존성에 추가해야 합니다.
+반면에 typescript는 선언 파일이 패키징되기 때문에, 별도의 의존성을 추가할 필요가 없습니다.
        
+
        이 패키지는 browserify와 typescript 패키지의 각 선언을 노출하기 때문에, browserify-typescript-extension 패키지는 이 의존성들을 가져야 합니다.
+이 이유로, "devDependencies"가 아니라 "dependencies"를 사용합니다. 왜냐하면 "devDependencies"를 사용하면 사용자가 직접 이 패키지들을 설치해야 하기 때문입니다.
+만약에 단지 명령줄 애플리케이션을 작성했고 패키지를 라이브러리로 사용하길 기대하지 않는다면, devDependencies를 사용해도 됩니다.
        
+
        경고 플래그 (Red flags)
        
 
        /// <reference path="..." />
        
-
        Don't use /// <reference path="..." /> in your declaration files.
        
+
        선언 파일에 /// <reference path="..." />를 사용하지 마세요.
        
 
        /// <reference path="../typescript/lib/typescriptServices.d.ts" />
 ....
 
        
-
        Do use /// <reference types="..." /> instead.
        
+
        대신 /// <reference types="..." />를 사용하세요.
        
 
        /// <reference types="typescript" />
 ....
 
        
-
        Make sure to revisit the Consuming dependencies section for more information.
        
-
        Packaging dependent declarations
        
-
        If your type definitions depend on another package:
        
+
        더 자세한 내용을 위해 의존성 사용하기 섹션을 다시 보십시오.
        
+
        의존적인 선언 패키징하기 (Packaging dependent declarations)
        
+
        만약 타입 정의가 다른 패키지에 의존적이라면:
        
 
          
-
        • Don't combine it with yours, keep each in their own file.
          • 
-
        • Don't copy the declarations in your package either.
          • 
-
        • Do depend on the npm type declaration package if it doesn't package its declaration files.
          • 
+
        • 각 파일은 유지하고 다른 패키지와 합치지 마세요.
          • 
+
        • 또한 작성한 패키지에 선언을 복사하지 마세요.
          • 
+
        • 만약 npm 타입 선언 패키지가 선언 파일을 패키징하지 않는다면, 해당 패키지에 의존하세요.
          • 
 
        
-
        Publish to @types
        
-
        Packages on under the @types organization are published automatically from DefinitelyTyped using the types-publisher tool.
-To get your declarations published as an @types package, please submit a pull request to https://github.com/DefinitelyTyped/DefinitelyTyped.
-You can find more details in the contribution guidelines page.
        
+
        @types에 배포하기 (Publish to @types)
        
+
        @types안에 있는 패키지들은 타입-배포 도구를 사용하여 DefinitelyTyped에서 자동으로 배포되었습니다.
+선언을 @types 패키지로 배포하려면, https://github.com/DefinitelyTyped/DefinitelyTyped에 pull request를 제출하세요.
+기여 지침 페이지에서 더 자세한 내용을 찾을 수 있습니다.
        
 
                                 
                                 
        
@@ -823,7 +870,7 @@ 
        No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Publishing","level":"4.7","depth":1,"next":{"title":"Consumption","level":"4.8","depth":1,"path":"pages/declaration files/Consumption.md","ref":"pages/declaration files/Consumption.md","articles":[]},"previous":{"title":"Templates","level":"4.6","depth":1,"path":"pages/declaration files/Templates.md","ref":"pages/declaration files/Templates.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/declaration files/Publishing.md","mtime":"2019-06-14T05:32:52.255Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"../..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Publishing","level":"4.7","depth":1,"next":{"title":"Consumption","level":"4.8","depth":1,"path":"pages/declaration files/Consumption.md","ref":"pages/declaration files/Consumption.md","articles":[]},"previous":{"title":"Templates","level":"4.6","depth":1,"path":"pages/declaration files/Templates.md","ref":"pages/declaration files/Templates.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/declaration files/Publishing.md","mtime":"2020-04-22T15:29:36.183Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"../..","book":{"language":""}});
         });
     
 
diff --git a/pages/declaration files/Templates.html b/pages/declaration files/Templates.html
index d170aca7..007083a2 100644
--- a/pages/declaration files/Templates.html	
+++ b/pages/declaration files/Templates.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
      • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
        • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
      • 
+        
      • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
        • 
+    
+        
      • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
        • 
     
-        
      • 
+        
      • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
        • 
     
-        
      • 
+        
      • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
      • 릴리즈 노트
        • 
+        
+        
+    
+        
      • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
        • 
+    
+
+    
 
     
      • 
 
@@ -763,7 +809,7 @@ 
        No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Templates","level":"4.6","depth":1,"next":{"title":"Publishing","level":"4.7","depth":1,"path":"pages/declaration files/Publishing.md","ref":"pages/declaration files/Publishing.md","articles":[]},"previous":{"title":"Deep Dive","level":"4.5","depth":1,"path":"pages/declaration files/Deep Dive.md","ref":"pages/declaration files/Deep Dive.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/declaration files/Templates.md","mtime":"2019-06-14T05:32:52.255Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"../..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Templates","level":"4.6","depth":1,"next":{"title":"Publishing","level":"4.7","depth":1,"path":"pages/declaration files/Publishing.md","ref":"pages/declaration files/Publishing.md","articles":[]},"previous":{"title":"Deep Dive","level":"4.5","depth":1,"path":"pages/declaration files/Deep Dive.md","ref":"pages/declaration files/Deep Dive.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/declaration files/Templates.md","mtime":"2020-04-21T14:05:40.597Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"../..","book":{"language":""}});
         });
     
 
diff --git a/pages/release notes/TypeScript 3.8.html b/pages/release notes/TypeScript 3.8.html
new file mode 100644
index 00000000..77dde166
--- /dev/null
+++ b/pages/release notes/TypeScript 3.8.html	
@@ -0,0 +1,1210 @@
+
+
+
+    
+        
+        
+        TypeScript 3.8 · GitBook
+        
+        
+				
+				
+        
+        
+        
+        
+        
+    
+    
+    
+
+    
+            
+                
+                
+                
+            
+                
+                
+                
+            
+                
+                
+                
+            
+                
+                
+                
+            
+                
+                
+                
+            
+        
+
+    
+
+    
+        
+    
+        
+    
+        
+    
+        
+    
+        
+    
+        
+    
+
+    
+    
+    
+
+        
+    
+    
+    
+    
+    
+    
+    
+    
+
+    
+    
+    
+    
+
+    
+    
+        
+
        
+    
        
+        
+            
+
+
+            
+                
+            
+        
+    
        
+
+    
        
+        
+            
        
+                
+                    
+
+
+
+
+
+
+                    
        
+                        
        
+                            
+
        
+    
        
+    
+                                
        
+                                
+                                
+
         타입-전용 Imports 와 Exports (Type-Only Imports and Exports)
        
+
        이 기능은 대부분의 사용자에겐 생각할 필요가 없을 수도 있지만; --isolatedModules, TypeScript의 transpileModule API, 또는 Babel에서 문제가 발생하면 이 기능과 관련이 있을 수 있습니다.
        
+
        TypeScript 3.8은 타입-전용 imports, exports를 위한 새로운 구문이 추가되었습니다.
        
+
        import type { SomeThing } from "./some-module.js";
+
+export type { SomeThing };
+
        
+
        import type은 타입 표기와 선언에 사용될 선언만 import 합니다.
+이는 항상 완전히 제거되므로, 런타임에 남아있는 것은 없습니다.
+마찬가지로, export type은 타입 문맥에 사용할 export만 제공하며, 이 또한 TypeScript의 출력물에서 제거됩니다.
        
+
        클래스는 런타임에 값을 가지고 있고 디자인-타임에 타입이 있으며 사용은 상황에-따라 다르다는 것을 유의해야 합니다.
+클래스를 import 하기 위해 import type을 사용하면, 확장 같은 것은 할 수 없습니다.
        
+
        import type { Component } from "react";
+
+interface ButtonProps {
+    // ...
+}
+
+class Button extends Component<ButtonProps> {
+    //               ~~~~~~~~~
+    // error! 'Component' only refers to a type, but is being used as a value here.
+
+    // ...
+}
+
        
+
        이전에 Flow를 사용해본 적이 있다면, 이 구문은 상당히 유사합니다.
+한 가지 차이점은 코드가 모호해 보이지 않도록 몇 가지 제한을 두었다는 것입니다.
        
+
        // 'Foo'만 타입인가? 혹은 모든 import 선언이 타입인가?
+// 이는 명확하지 않기 때문에 오류로 처리합니다.
+
+import type Foo, { Bar, Baz } from "some-module";
+//     ~~~~~~~~~~~~~~~~~~~~~~
+// error! A type-only import can specify a default import or named bindings, but not both.
+
        
+
        import type과 함께, TypeScript 3.8은 런타임 시 사용되지 않는 import에서 발생하는 작업을 제어하기 위해 새로운 컴파일러 플래그를 추가합니다: importsNotUsedAsValues.
+이 플래그는 3 가지 다른 값을 가집니다:
        
+
          
+
        • remove: 이는 imports를 제거하는 현재 동작이며, 계속 기본값으로 작동할 것이며, 기존 동작을 바꾸는 변화가 아닙니다.
          • 
+
        • preserve: 이는 사용되지 않는 값들을 모두 보존합니다. 이로 인해 imports/side-effects가 보존될 수 있습니다.
          • 
+
        • error: 이는 모든 (preserve option 처럼) 모든 imports를 보존하지만, import 값이 타입으로만 사용될 경우 오류를 발생시킵니다. 이는 실수로 값을 import하지 않지만 사이드 이팩트 import를 명시적으로 만들고 싶을 때 유용합니다.
          • 
+
        
+
        이 기능에 대한 더 자세한 정보는, import type선언이 사용될수 있는 범위를 확대하는 pull request, 와 관련된 변경 사항에서 찾을 수 있습니다.
        
+
         ECMAScript 비공개 필드 (ECMAScript Private Fields)
        
+
        TypeScript 3.8 은 ECMAScript의 stage-3 클래스 필드 제안의 비공개 필드를 지원합니다.
        
+
        class Person {
+    #name: string
+
+    constructor(name: string) {
+        this.#name = name;
+    }
+
+    greet() {
+        console.log(`Hello, my name is ${this.#name}!`);
+    }
+}
+
+let jeremy = new Person("Jeremy Bearimy");
+
+jeremy.#name
+//     ~~~~~
+// 프로퍼티 '#name'은 'Person' 클래스 외부에서 접근할 수 없습니다.
+// 이는 비공개 식별자를 가지기 때문입니다.
+
        
+
        일반적인 프로퍼티들(private 지정자로 선언한 것도)과 달리, 비공개 필드는 몇 가지 명심해야 할 규칙이 있습니다.
+그중 몇몇은:
        
+
          
+
        • 비공개 필드는 # 문자로 시작합니다. 때때로 이를 비공개 이름(private names) 이라고 부릅니다.
          • 
+
        • 모든 비공개 필드 이름은 이를 포함한 클래스 범위에서 유일합니다.
          • 
+
        • public 또는 private 같은 TypeScript 접근 지정자는 비공개 필드로 사용될 수 없습니다.  
          • 
+
        • JS 사용자로부터도 비공개 필드는 이를 포함한 클래스 밖에서 접근하거나 탐지할 수 없습니다! 때때로 이를 강한 비공개(hard privacy) 라고 부릅니다.
          • 
+
        
+
        "강한" 비공개와 별도로, 비공개 필드의 또 다른 장점은 유일하다는 것입니다.
+예를 들어, 일반적인 프로퍼티 선언은 하위클래스에서 덮어쓰기 쉽습니다.
        
+
        class C {
+    foo = 10;
+
+    cHelper() {
+        return this.foo;
+    }
+}
+
+class D extends C {
+    foo = 20;
+
+    dHelper() {
+        return this.foo;
+    }
+}
+
+let instance = new D();
+// 'this.foo' 는 각 인스턴스마다 같은 프로퍼티를 참조합니다.
+console.log(instance.cHelper()); // '20' 출력
+console.log(instance.dHelper()); // '20' 출력
+
        
+
        비공개 필드에서는, 포함하고 있는 클래스에서 각각의 필드 이름이 유일하기 때문에 이에 대해 걱정하지 않아도 됩니다.
        
+
        class C {
+    #foo = 10;
+
+    cHelper() {
+        return this.#foo;
+    }
+}
+
+class D extends C {
+    #foo = 20;
+
+    dHelper() {
+        return this.#foo;
+    }
+}
+
+let instance = new D();
+// 'this.#foo' 는 각 클래스안의 다른 필드를 참조합니다.
+console.log(instance.cHelper()); // '10' 출력
+console.log(instance.dHelper()); // '20' 출력
+
        
+
        알아 두면 좋은 또 다른 점은 다른 타입으로 비공개 필드에 접근하면 TypeError 를 발생한다는 것입니다.
        
+
        class Square {
+    #sideLength: number;
+
+    constructor(sideLength: number) {
+        this.#sideLength = sideLength;
+    }
+
+    equals(other: any) {
+        return this.#sideLength === other.#sideLength;
+    }
+}
+
+const a = new Square(100);
+const b = { sideLength: 100 };
+
+// Boom!
+// TypeError: attempted to get private field on non-instance
+// 이는 `b` 가 `Square`의 인스턴스가 아니기 때문에 실패 합니다.
+console.log(a.equals(b));
+
        
+
        마자막으로, 모든 일반 .js 파일 사용자들의 경우, 비공개 필드는 항상 할당되기 전에 선언되어야 합니다.
        
+
        class C {
+    // '#foo' 선언이 없습니다.
+    // :(
+
+    constructor(foo: number) {
+        // SyntaxError!
+        // '#foo'는 쓰여지기 전에 선언되어야 합니다.
+        this.#foo = foo;
+    }
+}
+
        
+
        JavaScript는 항상 사용자들에게 선언되지 않은 프로퍼티에 접근을 허용했지만, TypeScript는 항상 클래스 프로퍼티 선언을 요구했습니다.
+비공개 필드는, .js 또는 .ts 파일에서 동작하는지 상관없이 항상 선언이 필요합니다.
        
+
        class C {
+    /** @type {number} */
+    #foo;
+
+    constructor(foo: number) {
+        // 동작합니다.
+        this.#foo = foo;
+    }
+}
+
        
+
        구현에 대한 더 많은 정보는, the original pull request를 참고하세요
        
+
        어떤 것을 사용해야 할까요? (Which should I use?)
        
+
        이미 TypeScript 유저로서 어떤 종류의 비공개를 사용해야 하는지에 대한 많은 질문을 받았습니다: 주로, "private 키워드를 사용해야 하나요 아니면 ECMAScript의 해시/우물 (#) 비공개 필드를 사용해야 하나요?"
+상황마다 다릅니다!
        
+
        프로퍼티에서, TypeScript의 private 지정자는 완전히 지워집니다 - 이는 런타임에서는 완전히 일반 프로퍼티처럼 동작하며 이것이 private 지정자로 선언되었다고 알릴 방법이 없습니다.
+private 키워드를 사용할 때, 비공개는 오직 컴파일-타임/디자인-타임에만 시행되며, JavaScript 사용자에게는 전적으로 의도-기반입니다.
        
+
        class C {
+    private foo = 10;
+}
+
+// 이는 컴파일 타임에 오류이지만
+// TypeScript 가 .js 파일로 출력했을 때는
+// 잘 동작하며 '10'을 출력합니다.
+console.log(new C().foo);    // '10' 출력
+//                  ~~~
+// error! Property 'foo' is private and only accessible within class 'C'.
+
+// TypeScript 오류를 피하기 위한 "해결 방법" 으로
+// 캄파일 타임에 이것을 허용합니다.
+console.log(new C()["foo"]); // prints '10'
+
        
+
        이 같은 종류의 "약한 비공개(soft privacy)"는 사용자가 API에 접근할 수 없는 상태에서 일시적으로 작업을 하는 데 도움이 되며, 어떤 런타임에서도 동작합니다.
        
+
        반면에, ECMAScript의 # 비공개는 완벽하게 클래스 밖에서 접근 불가능합니다.
        
+
        class C {
+    #foo = 10;
+}
+
+console.log(new C().#foo); // SyntaxError
+//                  ~~~~
+// TypeScript 는 오류를 보고 하며 *또한*
+// 런타임에도 동작하지 않습니다.
+
+console.log(new C()["#foo"]); // undefined 출력
+//          ~~~~~~~~~~~~~~~
+// TypeScript 는 'noImplicitAny' 하에서 오류를 보고하며
+// `undefined`를 출력합니다.
+
        
+
        이런 강한 비공개(hard privacy)는 아무도 내부를 사용할 수 없도록 엄격하게 보장하는데 유용합니다.
+만약 라이브러리 작성자일 경우, 비공개 필드를 제거하거나 이름을 바꾸는 것이 급격한 변화를 초래서는 안됩니다.
        
+
        언급했듯이, 다른 장점은 ECMAScript의 # 비공개가 진짜 비공개이기 때문에 서브클래싱을 쉽게 할 수 있다는 것입니다.
+ECMAScript # 비공개 필드를 사용하면, 어떤 서브 클래스도 필드 네이밍 충돌에 대해 걱정할 필요가 없습니다.
+TypeScript의 private프로퍼티 선언에서는, 사용자는 여전히 상위 클래스에 선언된 프로퍼티를 짓밟지  않도록 주의해야 합니다.
        
+
        한 가지 더 생각해봐야 할 것은 코드가 실행되기를 의도하는 곳입니다.
+현재 TypeScript는 이 기능을 ECMAScript 2015 (ES6) 이상 버전을 대상으로 하지 않으면 지원할 수 없습니다.
+이는 하위 레벨 구현이 비공개를 강제하기 위해 WeakMap을 사용하는데, WeakMap은 메모리 누수를 잃으키지 않도록 폴리필될 수 없기 때문입니다.
+반면, TypeScript의 private-선언 프로퍼티는 모든 대상에서 동작합니다- ECMAScript3에서도!
        
+
        마지막 고려 사항은 속도 일수 있습니다: private 프로퍼티는 다른 어떤 프로퍼티와 다르지 않기 때문에, 어떤 런타임을 대상으로 하단 다른 프로퍼티와 마찬가지로 접근 속도가 빠를 수 있습니다.
+반면에, # 비공개 필드는 WeakMap을 이용해 다운 레벨 되기 때문에 사용 속도가 느려질 수 있습니다.
+어떤 런타임은 # 비공개 필드 구현을 최적화 하고, 더 빠른 WeakMap을 구현하고 싶을 수 있지만, 모든 런타임에서 그렇지 않을 수 있습니다.
        
+
         export * as ns 구문 (export * as ns Syntax)
        
+
        다른 모듈의 모든 멤버를 하나의 멤버로 내보내는 단일 진입점을 갖는 것은 종종 일반적입니다.
        
+
        import * as utilities from "./utilities.js";
+export { utilities };
+
        
+
        이는 매우 일반적이어서 ECMAScript2020은 최근에 이 패턴을 지원하기 위해서 새로운 구문을 추가했습니다.
        
+
        export * as utilities from "./utilities.js";
+
        
+
        이것은 JavaScript에 대한 훌륭한 삶의 질의 향상이며, TypeScript 3.8은 이 구문을 지원합니다.
+모듈 대상이 es2020 이전인 경우, TypeScript는 첫 번째 줄의 코드 스니펫을 따라서 무언가를 출력할 것입니다.
        
+
         최상위-레벨 await (Top-Level await)
        
+
        TypeScript 3.8은 "최상위-레벨 await"이라는 편리한 ECMAScript 기능을 지원합니다.
        
+
        JavaScript 사용자는 await을 사용하기 위해 async 함수를 도입하는 경우가 많으며, 이를 정의한 후 즉시 함수를 호출합니다.
        
+
        async function main() {
+    const response = await fetch("...");
+    const greeting = await response.text();
+    console.log(greeting);
+}
+
+main()
+    .catch(e => console.error(e))
+
        
+
        이전의 JavaScript(유사한 기능을 가진 대부분의 다른 언어들과 함께)에서 await은 async 함수 내에서 만 허용되었기 때문입니다.
+하지만 최상위-레벨 await로, 우리는 모듈의 최상위 레벨에서 await을 사용할 수 있습니다.
        
+
        const response = await fetch("...");
+const greeting = await response.text();
+console.log(greeting);
+
+// 모듈인지 확인
+export {};
+
        
+
        유의할 점이 있습니다: 최상위-레벨 await은 module의 최상위 레벨에서만 동작하며, 파일은 TypeScript가 import나 export를 찾을 때에만 모듈로 간주됩니다.
+일부 기본적인 경우에 export {}와 같은 보일러 플레이트를 작성하여 이를 확인할 필요가 있습니다.
        
+
        이러한 경우가 예상되는 모든 환경에서 최상위 레벨 await은 동작하지 않을 수 있습니다.
+현재, target 컴파일러 옵션이 es2017 이상이고, module이 esnext 또는 system인 경우에만 최상위 레벨 await을 사용할 수 있습니다.
+몇몇 환경과 번들러내에서의 지원은 제한적으로 작동하거나 실험적 지원을 활성화해야 할 수도 있습니다.
        
+
        구현에 관한 더 자세한 정보는 the original pull request을 확인하세요.
        
+
         es2020용 target과 module   (es2020 for target and module)
        
+
        TypeScript 3.8은 es2020을 module과 target 옵션으로 지원합니다.
+이를 통해 선택적 체이닝 (optional chaining), nullish 병합 (nullish coalescing), export * as ns 그리고 동적인 import(...) 구문과 같은 ECMAScript 2020 기능이 유지됩니다.
+또한 bigint 리터럴이 esnext 아래에 안정적인 target을 갖는 것을 의미합니다.
        
+
         JSDoc 프로퍼티 지정자 (JSDoc Property Modifiers)
        
+
        TypeScript 3.8는 allowJs 플래그를 사용하여 JavaScript 파일을 지원하고 checkJs 옵션이나 // @ts-check 주석을 .js 파일 맨 위에 추가하여 JavaScript 파일의 타입-검사를 지원합니다.
        
+
        JavaScript 파일에는 타입-검사를 위한 전용 구문이 없기 때문에 TypeScript는 JSDoc을 활용합니다.
+TypeScript 3.8은 프로퍼티에 대한 몇 가지 새로운 JSDoc 태그를 인식합니다.
        
+
        먼저 접근 지정자입니다: @public, @private 그리고 @protected입니다.
+이 태그들은 TypeScript 내에서 각각 public, private, protected와 동일하게 동작합니다.
        
+
        // @ts-check
+
+class Foo {
+    constructor() {
+        /** @private */
+        this.stuff = 100;
+    }
+
+    printStuff() {
+        console.log(this.stuff);
+    }
+}
+
+new Foo().stuff;
+//        ~~~~~
+// 오류! 'stuff' 프로퍼티는 private 이기 때문에 오직 'Foo' 클래스 내에서만 접근이 가능합니다.
+
        
+
          
+
        • @public은 항상 암시적이며 생략될 수 있지만, 어디서든 해당 프로퍼티에 접근 가능을 의미합니다.
          • 
+
        • @private은 오직 프로퍼티를 포함하는 클래스 내에서 해당 프로퍼티 사용 가능을 의미합니다.
          • 
+
        • @protected는 프로퍼티를 포함하는 클래스와 파생된 모든 하위 클래스내에서 해당 프로퍼티를 사용할 수 있지만, 포함하는 클래스의 인스턴스는 해당 프로퍼티를 사용할 수 없습니다.
          • 
+
        
+
        다음으로 @readonly 지정자를 추가하여 프로퍼티가 초기화 과정 내에서만 값이 쓰이는 것을 보장합니다.
        
+
        // @ts-check
+
+class Foo {
+    constructor() {
+        /** @readonly */
+        this.stuff = 100;
+    }
+
+    writeToStuff() {
+        this.stuff = 200;
+        //   ~~~~~
+        // 'stuff'는 읽기-전용(read-only) 프로퍼티이기 때문에 할당할 수 없습니다.
+    }
+}
+
+new Foo().stuff++;
+//        ~~~~~
+// 'stuff'는 읽기-전용(read-only) 프로퍼티이기 때문에 할당할 수 없습니다.
+
        
+
         리눅스에서 더 나은 디렉터리 감시와 watchOptions
        
+
        TypeScript 3.8에서는 node_modules의 변경사항을 효율적으로 수집하는데 중요한 새로운 디렉터리 감시 전략을 제공합니다.
        
+
        리눅스와 같은 운영체제에서 TypeScript는 node_modules에 디렉터리 왓쳐(파일 왓쳐와는 반대로)를 설치하고, 의존성 변화를 감지하기 위해 많은 하위 디렉터리를 설치합니다.
+왜냐하면 사용 가능한 파일 왓쳐의 수는 종종 node_modules의 파일 수에 의해 가려지기 때문이고, 추적할 디렉터리 수가 적기 때문입니다.
        
+
        TypeScript의 이전 버전은 폴더에 디렉터리 왓쳐를 즉시 설치하며, 초기에는 괜찮을 겁니다; 하지만, npm install 할 때, node_modules안에서 많은 일들이 발생할 것이고, TypeScript를 압도하여, 종종 에디터 세션을 아주 느리게 만듭니다.
+이를 방지하기 위해, TypeScript 3.8은 디렉터리 왓쳐를 설치하기 전에 조금 기다려서 변동성이 높은 디렉터리에게 안정될 수 있는 시간을 줍니다.
        
+
        왜냐하면 모든 프로젝트는 다른 전략에서 더 잘 작동할 수 있고, 이 새로운 방법은 당신의 작업 흐름에서는 잘 맞지 않을 수 있습니다. TypeScript 3.8은 파일과 디렉터리를 감시하는데 어떤 감시 전략을 사용할지 컴파일러/언어 서비스에 알려줄 수 있도록 tsconfig.json과 jsconfig.json에 watchOptions란 새로운 필드를 제공합니다.
        
+
        {
+    // 일반적인 컴파일러 옵션들
+    "compilerOptions": {
+        "target": "es2020",
+        "moduleResolution": "node",
+        // ...
+    },
+
+    // NEW: 파일/디렉터리 감시를 위한 옵션
+    "watchOptions": {
+        // 파일과 디렉터리에 네이티브 파일 시스템 이벤트 사용
+        "watchFile": "useFsEvents",
+        "watchDirectory": "useFsEvents",
+
+        // 업데이트가 빈번할 때
+        // 업데이트하기 위해 더 자주 파일을 폴링
+        "fallbackPolling": "dynamicPriority"
+    }
+}
+
        
+
        watchOptions는 구성할 수 있는 4가지 새로운 옵션이 포함되어 있습니다.
        
+
          
+
        • watchFile: 각 파일의 감시 방법 전략. 다음과 같이 설정할 수 있습니다:
            
+
          • fixedPollingInterval: 고정된 간격으로 모든 파일의 변경을 1초에 여러 번 검사합니다.
            • 
+
          • priorityPollingInterval: 모든 파일의 변경을 1초에 여러 번 검사합니다, 하지만 휴리스틱을 사용하여 특정 타입의 파일은 다른 타입의 파일보다 덜 자주 검사합니다.
            • 
+
          • dynamicPriorityPolling: 동적 큐를 사용하여 덜-자주 수정된 파일은 적게 검사합니다.
            • 
+
          • useFsEvents (디폴트): 파일 변화에 운영체제/파일 시스템의 네이티브 이벤트를 사용합니다.
            • 
+
          • useFsEventsOnParentDirectory: 파일을 포함하고 있는 디렉터리 변경을 감지할 때, 운영체제/파일 시스템의 네이티브 이벤트를 사용합니다. 파일 왓쳐를 적게 사용할 수 있지만, 덜 정확할 수 있습니다.
            • 
+
          
+
          • 
+
        • watchDirectory: 재귀적인 파일-감시 기능이 없는 시스템 안에서 전체 디렉터리 트리가 감시되는 전략. 다음과 같이 설정할 수 있습니다:
            
+
          • fixedPollingInterval: 고정된 간격으로 모든 디렉터리의 변경을 1초에 여러 번 검사합니다.
            • 
+
          • dynamicPriorityPolling: 동적 큐를 사용하여 덜-자주 수정된 디렉터리는 적게 검사합니다.
            • 
+
          • useFsEvents (디폴트): 디렉터리 변경에 운영체제/파일 시스템의 네이티브 이벤트를 사용합니다.
            • 
+
          
+
          • 
+
        • fallbackPolling: 파일 시스템 이벤트를 사용할 때, 이 옵션은 시스템이 네이티브 파일 왓쳐가 부족하거나/혹은 지원하지 않을 때, 사용되는 폴링 전략을 지정합니다. 다음과 같이 설정할 수 있습니다.
            
+
          • fixedPollingInterval: (위를 참조하세요.)
            • 
+
          • priorityPollingInterval: (위를 참조하세요.)
            • 
+
          • dynamicPriorityPolling: (위를 참조하세요.)
            • 
+
          
+
          • 
+
        • synchronousWatchDirectory: 디렉터리의 연기된 감시를 비활성화합니다. 연기된 감시는 많은 파일이 한 번에 변경될 때 유용합니다 (예를 들어, npm install을 실행하여 node_modules의 변경), 하지만 덜-일반적인 설정을 위해 비활성화할 수도 있습니다.
          • 
+
        
+
        이 변경의 더 자세한 내용은 Github으로 이동하여 the pull request를 읽어보세요.
        
+
         "빠르고 느슨한" 증분 검사
        
+
        TypeScript 3.8은 새로운 컴파일러 옵션 assumeChangesOnlyAffectDirectDepencies을 제공합니다.
+이 옵션이 활성화되면, TypeScript는 정말로 영향을 받은 파일들은 재검사/재빌드하지않고, 변경된 파일뿐만 아니라 직접 import 한 파일만 재검사/재빌드 합니다.
        
+
        예를 들어, 다음과 같이 fileA.ts를 import 한 fileB.ts를 import 한 fileC.ts를 import 한 fileD.ts를 살펴봅시다:
        
+
        fileA.ts <- fileB.ts <- fileC.ts <- fileD.ts
+
        
+
        --watch 모드에서는, fileA.ts의 변경이 fileB.ts, fileC.ts 그리고 fileD.ts를 TypeScript가 재-검사해야 한다는 의미입니다.
+assumeChangesOnlyAffectDirectDependencies에서는 fileA.ts의 변경은 fileA.ts와 fileB.ts만 재-검사하면 됩니다.
        
+
        Visual Studio Code와 같은 코드 베이스에서는, 특정 파일의 변경에 대해 약 14초에서 약 1초로 재빌드 시간을 줄여주었습니다.
+이 옵션을 모든 코드 베이스에서 추천하는 것은 아니지만, 큰 코드 베이스를 가지고 있고, 나중까지 전체 프로젝트 오류를 기꺼이 연기하겠다면 (예를 들어, tsconfig.fullbuild.json이나 CI를 통한 전용 빌드) 흥미로울 것입니다.
        
+
        더 자세한 내용은 the original pull request에서 보실 수 있습니다.
        
+
+                                
+                                
        
+                            
+    
        
+    
        
+        
        
+            
+            
         results matching ""
        
+            
          
+            
+        
          
+        
          
+            
+            
          No results matching ""
          
+            
+        
          
+    
          
+
          
+
+                        
          
+                    
          
+                
+            
          
+
+            
+                
+                
+                    
+                
+                
+                
+            
+        
+    
          
+
+    
+
          
+
+        
+    
+    
+    
+    
+        
+        
+        
+    
+        
+        
+        
+    
+        
+        
+        
+    
+        
+        
+        
+    
+        
+        
+        
+    
+        
+        
+        
+    
+        
+        
+        
+    
+
+    
+
+    
+
diff --git a/pages/tsconfig.json.html b/pages/tsconfig.json.html
index 1b09d78a..536bc5aa 100644
--- a/pages/tsconfig.json.html
+++ b/pages/tsconfig.json.html
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
        • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
          • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
        • 
+        
        • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
          • 
+    
+        
        • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
          • 
     
-        
        • 
+        
        • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
          • 
     
-        
        • 
+        
        • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
        • 릴리즈 노트
          • 
+        
+        
+    
+        
        • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
          • 
+    
+
+    
 
     
        • 
 
@@ -811,7 +857,8 @@ 
          @types, typeRoots이 tsconfig.json은 오직 ./node_modules/@types/node, ./node_modules/@types/lodash 및 ./node_modules/@types/express만 포함합니다.
          node_modules/@types/* 아래의 다른 패키지는 포함되지 않습니다.
          
 
          types 패키지는 index.d.ts 파일이 있는 폴더 또는 폴더에 types 필드를 가진 package.json가 있는 폴더입니다.
          
 
          "types": []를 지정하면 @types 패키지가 자동으로 포함되지 않습니다.
          
-
          전역 선언이 포함된 파일을 사용하는 경우에만 자동 포함이 중요하다는 점에 명심하세요 (모듈로 선언된 파일과 달리).
          예를 들어 import "foo" 문을 사용한다면 TypeScript는 여전히 node_modules & node_modules/@types 폴더를 보고 foo 패키지를 찾을 것입니다. 
          
+
          전역 선언이 포함된 파일을 사용하는 경우에만 자동 포함이 중요하다는 점에 명심하세요 (모듈로 선언된 파일과 달리).
+예를 들어 import "foo" 문을 사용한다면 TypeScript는 여전히 node_modules & node_modules/@types 폴더를 보고 foo 패키지를 찾을 것입니다.
          
 
          extends를 이용한 설정 상속 (Configuration inheritance with extends)
          
 
          tsconfig.json 파일은 extends 속성을  사용해 다른 파일의 설정을 상속할 수 있습니다.
          
 
          extends는 tsconfig.json의 최상위 속성 (compilerOptions,files,include 및 exclude와 함께) 입니다.
          extends' 값은 상속받을 다른 설정 파일의 경로를 포함하는 문자열입니다.
          
@@ -898,7 +945,7 @@ 
          No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"tsconfig.json","level":"5.1","depth":1,"next":{"title":"컴파일러 옵션","level":"5.2","depth":1,"path":"pages/Compiler Options.md","ref":"pages/Compiler Options.md","articles":[]},"previous":{"title":"Consumption","level":"4.8","depth":1,"path":"pages/declaration files/Consumption.md","ref":"pages/declaration files/Consumption.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/tsconfig.json.md","mtime":"2019-06-14T05:32:52.260Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"tsconfig.json","level":"5.1","depth":1,"next":{"title":"컴파일러 옵션","level":"5.2","depth":1,"path":"pages/Compiler Options.md","ref":"pages/Compiler Options.md","articles":[]},"previous":{"title":"Consumption","level":"4.8","depth":1,"path":"pages/declaration files/Consumption.md","ref":"pages/declaration files/Consumption.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/tsconfig.json.md","mtime":"2020-04-22T15:29:36.186Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"..","book":{"language":""}});
         });
     
 
diff --git a/pages/tutorials/ASP.NET Core.html b/pages/tutorials/ASP.NET Core.html
index 9042d5cd..e9cb6f43 100644
--- a/pages/tutorials/ASP.NET Core.html	
+++ b/pages/tutorials/ASP.NET Core.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
        • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
          • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
        • 
+        
        • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
          • 
+    
+        
        • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
          • 
     
-        
        • 
+        
        • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
          • 
     
-        
        • 
+        
        • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
        • 릴리즈 노트
          • 
+        
+        
+    
+        
        • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
          • 
+    
+
+    
 
     
        • 
 
@@ -1051,7 +1097,7 @@ 
          No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"ASP.NET Core","level":"2.2","depth":1,"next":{"title":"걸프","level":"2.3","depth":1,"path":"pages/tutorials/Gulp.md","ref":"pages/tutorials/Gulp.md","articles":[]},"previous":{"title":"5분 안에 보는 TypeScript","level":"2.1","depth":1,"path":"pages/tutorials/TypeScript in 5 minutes.md","ref":"pages/tutorials/TypeScript in 5 minutes.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/tutorials/ASP.NET Core.md","mtime":"2019-06-14T05:32:52.260Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"../..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"ASP.NET Core","level":"2.2","depth":1,"next":{"title":"걸프","level":"2.3","depth":1,"path":"pages/tutorials/Gulp.md","ref":"pages/tutorials/Gulp.md","articles":[]},"previous":{"title":"5분 안에 보는 TypeScript","level":"2.1","depth":1,"path":"pages/tutorials/TypeScript in 5 minutes.md","ref":"pages/tutorials/TypeScript in 5 minutes.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/tutorials/ASP.NET Core.md","mtime":"2020-04-22T15:29:36.186Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"../..","book":{"language":""}});
         });
     
 
diff --git a/pages/tutorials/Gulp.html b/pages/tutorials/Gulp.html
index 0d4ac375..51a0b380 100644
--- a/pages/tutorials/Gulp.html
+++ b/pages/tutorials/Gulp.html
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
        • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
          • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
        • 
+        
        • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
          • 
+    
+        
        • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
          • 
     
-        
        • 
+        
        • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
          • 
     
-        
        • 
+        
        • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
        • 릴리즈 노트
          • 
+        
+        
+    
+        
        • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
          • 
+    
+
+    
 
     
        • 
 
@@ -1075,7 +1121,7 @@ 
          No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"걸프","level":"2.3","depth":1,"next":{"title":"JavaScript에서 마이그레이션","level":"2.4","depth":1,"path":"pages/tutorials/Migrating from JavaScript.md","ref":"pages/tutorials/Migrating from JavaScript.md","articles":[]},"previous":{"title":"ASP.NET Core","level":"2.2","depth":1,"path":"pages/tutorials/ASP.NET Core.md","ref":"pages/tutorials/ASP.NET Core.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/tutorials/Gulp.md","mtime":"2019-06-14T05:32:52.261Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"../..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"걸프","level":"2.3","depth":1,"next":{"title":"JavaScript에서 마이그레이션","level":"2.4","depth":1,"path":"pages/tutorials/Migrating from JavaScript.md","ref":"pages/tutorials/Migrating from JavaScript.md","articles":[]},"previous":{"title":"ASP.NET Core","level":"2.2","depth":1,"path":"pages/tutorials/ASP.NET Core.md","ref":"pages/tutorials/ASP.NET Core.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/tutorials/Gulp.md","mtime":"2020-04-22T13:02:03.092Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"../..","book":{"language":""}});
         });
     
 
diff --git a/pages/tutorials/Migrating from JavaScript.html b/pages/tutorials/Migrating from JavaScript.html
index 2824afa6..e97573af 100644
--- a/pages/tutorials/Migrating from JavaScript.html	
+++ b/pages/tutorials/Migrating from JavaScript.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
        • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
          • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
        • 
+        
        • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
          • 
+    
+        
        • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
          • 
     
-        
        • 
+        
        • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
          • 
     
-        
        • 
+        
        • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
        • 릴리즈 노트
          • 
+        
+        
+    
+        
        • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
          • 
+    
+
+    
 
     
        • 
 
@@ -794,7 +840,7 @@ 
          Webpack
          
     // 다른 옵션들...
 };
 
          
-
          .js 파일을 다루는 다른 로더보다 awesome-typescript-loader를 먼저 실행해야 한다는 점에 주의해야 합니다.
          Webpack을 위한 TypeScript 로더인 ts-loader도 마찬가지입니다.
          여기에서. 그 둘의 차이점에 대해 더 읽어볼 수 있다. 
          
+
          .js 파일을 다루는 다른 로더보다 awesome-typescript-loader를 먼저 실행해야 한다는 점에 주의해야 합니다.
          Webpack을 위한 TypeScript 로더인 ts-loader도 마찬가지입니다.
          여기에서. 그 둘의 차이점에 대해 더 읽어볼 수 있다.
          
 
          React and Webpack에 관한 튜토리얼에서 Webpack을 사용하는 예를 볼 수 있습니다.
          
 
          TypeScript 파일로 이동 (Moving to TypeScript Files)
          
 
          이때 TypeScript 파일을 사용할 준비가 된 것입니다.
          첫 번째 단계는 .js 파일 중 하나의 이름을 .ts로 바꾸는 것입니다.
          파일이 JSX를 사용한다면 이름을 .tsx로 바꿔야 합니다.
          
@@ -1009,7 +1055,7 @@ 
          No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"JavaScript에서 마이그레이션","level":"2.4","depth":1,"next":{"title":"리액트 & 웹팩","level":"2.5","depth":1,"path":"pages/tutorials/React & Webpack.md","ref":"pages/tutorials/React & Webpack.md","articles":[]},"previous":{"title":"걸프","level":"2.3","depth":1,"path":"pages/tutorials/Gulp.md","ref":"pages/tutorials/Gulp.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/tutorials/Migrating from JavaScript.md","mtime":"2019-06-14T05:32:52.262Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"../..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"JavaScript에서 마이그레이션","level":"2.4","depth":1,"next":{"title":"리액트 & 웹팩","level":"2.5","depth":1,"path":"pages/tutorials/React & Webpack.md","ref":"pages/tutorials/React & Webpack.md","articles":[]},"previous":{"title":"걸프","level":"2.3","depth":1,"path":"pages/tutorials/Gulp.md","ref":"pages/tutorials/Gulp.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/tutorials/Migrating from JavaScript.md","mtime":"2020-04-22T15:29:36.187Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"../..","book":{"language":""}});
         });
     
 
diff --git a/pages/tutorials/React & Webpack.html b/pages/tutorials/React & Webpack.html
index ce5b50ea..c11272de 100644
--- a/pages/tutorials/React & Webpack.html	
+++ b/pages/tutorials/React & Webpack.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
        • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
          • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
        • 
+        
        • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
          • 
+    
+        
        • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
          • 
     
-        
        • 
+        
        • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
          • 
     
-        
        • 
+        
        • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
        • 릴리즈 노트
          • 
+        
+        
+    
+        
        • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
          • 
+    
+
+    
 
     
        • 
 
@@ -711,88 +757,97 @@ 
          
     
                                 
          
                                 
-                                
          이 가이드에서는 TypeScript를 React와 webpack으로 묶는 방법을 가르쳐줄 것입니다.
          
-
          새로운 프로젝트를 시작하려면 먼저 React Quick Start guide를 살펴보세요.
          
-
          그렇지 않으면 npm과 Node.js를 이미 사용하고 있다고 가정합니다.
          
+                                
          이 가이드는 TypeScript를 React 및 webpack에 연결하는 방법을 알려줍니다.
          
+
          새로운 프로젝트를 시작하는 경우, 먼저 React Quick Start guide를 살펴보세요.
          
+
          그렇지 않으면 이미 npm과 함께 Node.js를 사용하고 있다고 가정합니다.
          
 
          프로젝트 배치 (Lay out the project)
          
-
          새로운 디렉토리부터 시작합시다. 지금은 이름을 proj로 지정했지만 원하는대로 변경할 수 있습니다.
          
+
          새 디렉토리부터 시작하겠습니다.
+지금은 이름을 proj라고 지정하지만, 원하는대로 변경할 수 있습니다.
          
 
          mkdir proj
 cd proj
 
          
-
          시작하려면 다음과 같은 방식으로 프로젝트를 구성해야합니다:
          
+
          시작하기 위해, 다음과 같은 방식으로 프로젝트를 구성하겠습니다:
          
 
          proj/
 ├─ dist/
 └─ src/
    └─ components/
 
          
-
          TypeScript 파일은 src 폴더에서 시작한 TypeScript는 컴파일 후 webpack을 실행하여 dist의 bundle.js 파일로 끝납니다.
          작성된 모든 구성 요소는src / components 폴더에 들어갑니다.
          
-
          이것을 골격으로 합니다:
          
+
          TypeScript 파일은 src 폴더에서 시작하여, TypeScript 컴파일러를 통해 실행한 다음, webpack을 거쳐 dist의 main.js 파일로 끝납니다.
+우리가 작성하는 모든 컴포넌트는 src/components 폴더 안에 있습니다.
          
+
          이것을 기본 뼈대로 구성합니다:
          
 
          mkdir src
 cd src
 mkdir components
 cd ..
 
          
-
          Webpack은 결국 dist 디렉토리를 생성할 것입니다.
          
+
          Webpack으로 마지막엔 dist폴더를 생성할 것입니다.
          
 
          프로젝트 초기화 (Initialize the project)
          
-
          이제 이 폴더를 npm 패키지로 바꿀 것입니다.
          
-
          npm init
+
          이제 이 폴더를 npm 패키지로 바꿀 것 입니다.
          
+
          npm init -y
 
          
-
          주의사항이 표시되지만 기본값을 자유롭게 사용할 수 있습니다.
          사용자를 위해 생성된 package.json 파일에서 언제든 기본값을 변경할 수 있습니다.
          
+
          기본값으로 package.json 파일이 생성됩니다.
          
 
          의존성 설치 (Install our dependencies)
          
-
          먼저 Webpack이 글로벌으로 설치되어 있는지 확인해보세요.
          
-
          npm install -g webpack
+
          먼저 Webpack이 설치되어 있는지 확인합니다.
          
+
          npm install --save-dev webpack webpack-cli
 
          
-
          Webpack은 사용자의 코드를 번들(묶어서)로 제공하고 선택적으로 모든 의존성을 단 하나의 .js 파일로 번들링(묶는)하는 도구입니다.
          
-
          이제 React와 React-DOM을 package.json 파일의 의존성으로 추가하겠습니다:
          
-
          npm install --save react react-dom @types/react @types/react-dom
+
          Webpack은 코드와 선택적으로 모든 의존성을 하나의 .js파일로 묶는 도구입니다.
          
+
          이제 선언 파일과 함께 React 및 React-DOM을 package.json 파일에 의존성으로 추가하겠습니다:
          
+
          npm install --save react react-dom
+npm install --save-dev @types/react @types/react-dom
 
          
-
          @types/ 접두사는 React와 React-DOM을 위한 선언 파일을 가져온다는 것을 의미합니다.
          일반적으로 "react"와 같은 경로를 가져 오면 react 패키지 자체를 살펴봅니다.
          그러나 모든 패키지가 선언 파일을 포함하는 것은 아니므로 TypeScript는 또한 @types/react 패키지를 찾습니다.
          나중에는 이 일에 대해 생각할 필요도 없다는 걸 알게 될 것입니다.
          
-
          다음으로 awesome-typescript-loader와 source-map-loader에 development-time 의존성을 추가할 것입니다.
          
-
          npm install --save-dev typescript awesome-typescript-loader source-map-loader
+
          @types/ 접두사는 React와 React-DOM의 선언 파일을 가져오고 싶다는 것을 의미합니다.
+일반적으로 "react"와 같은 경로를 가져오면, react 패키지 자체를 살펴볼 것입니다;
+그러나 모든 패키지에 선언 파일이 포함되어 있지 않기 때문에, TypeScript는 @types/react 패키지도 찾습니다.
+나중에는 이것에 대해 생각할 필요가 없다는 것을 알 수 있습니다.
          
+
          다음으로, 개발 시 필요한 의존성에 ts-loader와source-map-loader를 추가합니다.
          
+
          npm install --save-dev typescript ts-loader source-map-loader
 
          
-
          이러한 의존성 둘 다 TypeScript와 webpack이 함께 잘 작동하도록 할 것 입니다.
          awesome-typescript-loader는 Webpack이 TypeScript의 표준 구성 파일 tsconfig.json을 사용하여 TypeScript 코드를 컴파일하는 데 도움이 됩니다.
          source-map-loader는 TypeScript의 모든 소스 맵 출력을 사용하여 자체 소스 맵을 생성 할 때 webpack에 알립니다.
          이렇게하면 원래 TypeScript 소스 코드를 디버깅 하듯이 최종 출력 파일을 디버깅 할 수 있습니다.
          
-
          awesome-typescript-loader가 typescript의 유일한 로더는 아닙니다.
          대신 ts-loader를 사용할 수 있습니다.
          여기에서  두 로더 사이의 차이점에 대해 읽어보세요.
          
-
          개발 의존성으로 TypeScript를 설치했음을 주목하십시오.
          TypeScript를 npm link typescript로 글로벌 사본에 연결할 수 있었는데 이것은 흔치 않은 경우입이다.
          
-
          TypeScript 설정 파일 추가 (Add a TypeScript configuration file)
          
-
          TypeScript 파일을 함께 가져오고 싶다면 필요한 선언 파일뿐만 아니라 작성할 코드 모두 작성하세요.
          
-
          이렇게 하려면 모든 컴파일 설정과 함께 입력 파일 목록이 포함된 tsconfig.json을 생성해야 합니다.
          프로젝트 루트에 tsconfig.json이라는 이름의 새 파일을 만들고 내용을 다음과 같이 채우기만 하면 됩니다:
          
+
          이 의존성들은  TypeScript와 Webpack을 같이 쓸 수 있게 해줍니다.
+ts-loader는 Webpack이 tsconfig.json이라는 TypeScript 표준 구성 파일을 사용하여 TypeScript 코드를 컴파일하도록 도와줍니다.
+source-map-loader는 TypeScript의 소스 맵 출력을 사용하여 고유한 소스 맵을 생성할 때 Webpack에 알립니다.
+이렇게 하면 기존의 TypeScript 소스 코드를 디버깅하는 것 처럼 최종 출력 파일을 디버깅 할 수 있습니다.
          
+
          ts-loader가 TypeScript의 유일한 로더는 아님을 유의해주세요
          
+
          TypeScript를 개발 의존성으로  설치했다는 것에 유의하세요.
+npm link typescript를 사용하여 TypeScript를 전역 복사본에 연결할 수도 있지만, 덜 일반적인 시나리오입니다.
          
+
          TypeScript 구성 파일 추가 (Add a TypeScript configuration file)
          
+
          작성하려는 코드와 필요한 선언 파일 모두 TypeScript 파일로 가져오기를 원할 것입니다.
          
+
          이렇게 하려면, 입력 파일 목록과 모든 컴파일 설정을 포함하는 tsconfig.json 파일을 만들어야 합니다.
+프로젝트 루트에 tsconfig.json이라는 새 파일을 생성하고, 다음 내용을 채우세요:
          
 
          {
     "compilerOptions": {
         "outDir": "./dist/",
         "sourceMap": true,
         "noImplicitAny": true,
         "module": "commonjs",
-        "target": "es5",
+        "target": "es6",
         "jsx": "react"
-    },
-    "include": [
-        "./src/**/*"
-    ]
+    }
 }
 
          
-
          tsconfig.json 파일에 대한 자세한 내용은 여기를 참조하십시오.
          
-
          몇 가지 코드 작성 (Write some code)
          
-
          React를 사용하여 첫 번째 TypeScript 파일을 작성해 보겠습니다.
          먼저src/components에 Hello.tsx라는 이름의 파일을 만들고 다음과 같이 작성합니다:
          
+
          tsconfig.json 파일에 대한 자세한 내용은 여기를 참조하세요.
          
+
          코드 작성하기 (Write some code)
          
+
          React를 사용하여 첫 번째 TypeScript 파일을 작성해 봅시다.
+먼저, src/components에 Hello.tsx 파일을 만들고 다음과 같이 작성하세요:
          
 
          import * as React from "react";
 
 export interface HelloProps { compiler: string; framework: string; }
 
 export const Hello = (props: HelloProps) => <h1>Hello from {props.compiler} and {props.framework}!</h1>;
 
          
-
          이 예제에서는 stateless functional components를 사용하는 경우에 대비하여 예제를 좀 더 고급스럽게 만들 수도 있습니다.
          
+
          이 예제는 함수 컴포넌트를 사용하지만, 예제를 조금 더 고급스럽게 만들 수 있습니다.
          
 
          import * as React from "react";
 
 export interface HelloProps { compiler: string; framework: string; }
 
-// 'HelloProps'는 props의 형태을 만듭니다.
-// State가 설정되어 있지 않아 '{}'타입을 사용합니다.
+// 'HelloProps'는 props의 형태를 나타냅니다.
+// state는 설정되지 않으므로, `{}` 타입을 사용합니다.
 export class Hello extends React.Component<HelloProps, {}> {
     render() {
         return <h1>Hello from {this.props.compiler} and {this.props.framework}!</h1>;
     }
 }
 
          
-
          그런 다음 src에 index.tsx를 생성해 봅시다 :
          
+
          다음 소스를 이용하여 src에 index.tsx를 생성합니다.
          
 
          import * as React from "react";
 import * as ReactDOM from "react-dom";
 
@@ -803,8 +858,11 @@ 
          document.getElementById("example")
 );
 
          
-
          Hello 컴포넌트를 index.tsx로 가져왔습니다.
          "react" 또는 "react-dom"과 달리 Hello.tsx에 대한 상대 경로를 사용했음을 주목하세요 - 이것은 중요합니다.
          그렇지 않다면 TypeScript는 대신node_modules 폴더를 살펴 보았을 겁니다.
          
-
          또한 Hello 컴포넌트를 보여줄 페이지가 필요합니다.
          다음과 같은 내용을 담은 index.html파일을 proj의 루트에 만듭니다:
          
+
          방금 Hello 컴포넌트를 index.tsx로 가져왔습니다.
+"react"나 "react-dom"과는 달리, Hello.tsx에 대한 상대 경로를 사용했다는 것에 유의하세요. - 이것은 중요합니다.
+그렇지 않은 경우, TypeScript는 대신 node_modules 폴더를 찾았습니다.
          
+
          Hello 컴포넌트를 표시할 페이지도 필요합니다.
+proj의 루트에 index.html 파일을 생성하고 다음과 같이 작성하세요:
          
 
          <!DOCTYPE html>
 <html>
     <head>
@@ -819,58 +877,70 @@ 
          <script src="./node_modules/react-dom/umd/react-dom.development.js"></script>
 
         <!-- Main -->
-        <script src="./dist/bundle.js"></script>
+        <script src="./dist/main.js"></script>
     </body>
 </html>
 
          
-
          node_modules에서 파일을 포함하고 있음을 주목하십시오.
          React와 React-DOM의 npm 패키지에는 웹 페이지에 포함할 수 있는 독립적인 .js 파일이 포함되어 있으며
          이를 빠르게 위해 직접 참조하고 있습니다.
-이러한 파일을 다른 디렉토리에 자유롭게 복사하거나 CDN을 통해 호스팅하는 것이 좋습니다.
          페이스북은 React의 CDN 호스팅 버전을 제공하며 여기에서 더 자세한 내용을 볼 수 있습니다.
          
-
          웹팩 설정 파일 만들기 (Create a webpack configuration file)
          
-
          프로젝트의 루트에 webpack.config.js 파일을 만듭니다.
          
+
          우리는 node_modules 안에 들어있는 파일을 포함시킵니다.
+React와 React-DOM의 npm 패키지에는 웹 페이지에 포함 할 수 있는 독립형 .js 파일이 있으며, 보다 빠르게 이동하기 위해 직접 찹조합니다.
+이런 파일을 다른 디렉토리에 복사하거나, CDN(Content Delivery Network)에서 호스팅합니다.
+Facebook은 CDN-호스트 버전의 React를 제공하며, 여기에서 자세한 내용을 읽을 수 있습니다.
          
+
          Webpack 구성 파일 생성하기 (Create a webpack configuration file)
          
+
          프로젝트 디렉토리의 루트에 webpack.config.js 파일을 생성합니다.
          
 
          module.exports = {
-    entry: "./src/index.tsx",
-    output: {
-        filename: "bundle.js",
-        path: __dirname + "/dist"
-    },
+    mode: "production",
 
-    // webpack의 출력을 디버깅 할 소스 맵을 사용하도록 설정합니다.
+    // Webpack의 출력물에서 디버깅을 하기위해 소스 맵을 허용합니다.
     devtool: "source-map",
 
     resolve: {
-        // 확인 가능한 확장자로 '.ts' 및 '.tsx'를 추가합니다.
-        extensions: [".ts", ".tsx", ".js", ".json"]
+        // 확인 가능한 확장자로 '.ts' 와 '.tsx' 를 추가합니다.
+        extensions: [".ts", ".tsx"]
     },
 
     module: {
         rules: [
-            // '.ts' 또는 '.tsx' 확장자를 가진 모든 파일은 'awesome-typescript-loader'에 의해 처리됩니다.
-            { test: /\.tsx?$/, loader: "awesome-typescript-loader" },
-
-            // '.js' 파일의 모든 출력에는 'source-maps-loader'로 다시 처리된 소스 맵이 있습니다.
-            { enforce: "pre", test: /\.js$/, loader: "source-map-loader" }
+            {
+                test: /\.ts(x?)$/,
+                exclude: /node_modules/,
+                use: [
+                    {
+                        loader: "ts-loader"
+                    }
+                ]
+            },
+            // 모든 '.js' 출력 파일은 'source-map-loader'에서 다시 처리한 소스 맵이 있습니다.
+            {
+                enforce: "pre",
+                test: /\.js$/,
+                loader: "source-map-loader"
+            }
         ]
     },
 
-    // 경로가 다음 중 하나와 일치하는 모듈을 임포트 경우
-    // 해당하는 글로벌 변수가 있다고 가정하고 대신 사용하세요.
-    // 이는 브라우저가 빌드와 라이브러리 사이에 캐시 할 수 있게 해주는
-    // 모든 종속성을 번들로 묶는 것을 피할 수 있기 때문에 중요합니다.
+    // 경로가 다음 중 하나와 일치하는 모듈을 가져올 때,
+    // 해당 전역 변수가 있다고 가정하고 사용합니다.
+    // 브라우저가 빌드간에 라이브러리를 캐시 할 수 있도록
+    // 모든 의존성을 묶지 않아도 되기 때문에 중요합니다.
     externals: {
         "react": "React",
         "react-dom": "ReactDOM"
-    },
+    }
 };
 
          
-
          아마도 externals 필드에 대해 궁금해 할지도 모릅니다.
          이렇게 하면 컴파일 시간이 증가하고 브라우저가 일반적으로 라이브러리를 변경하지 않을 경우 캐시 할 수 있으므로 모든 React 파일을 동일한 파일로 번들링하는 것을 방지합니다.
          
-
          이상적으로는 브라우저에서 React 모듈을 임포트하는 것 뿐이지만 대부분의 브라우저들은 아직도 모듈을 완전히 지원하지 않습니다.
          대신 라이브러리는 전통적으로 jQuery 나 _와 같은 글로벌 하게 사용하여 자체적으로 사용할 수 있게 했습니다.
          이를 "네임 스페이스 패턴"이라고 하며 webpack을 사용하면 이러한 방식으로 작성된 라이브러리를 계속 활용할 수 있습니다.
          
-
          "react"에 대한 entry를 사용하면 : webpack은 "React" 변수에서 "react"를 불러오기 위해 마술을 사용합니다.
          
-
          webpack 설정에 대한 자세한 내용은 여기를 참조하십시오.
          
+
          externals 필드에 대해 궁금할 것 입니다.
+컴파일 시간이 증가하고 브라우저가 라이브러리를 변경하지 않으면, 일반적으로 라이브러리를 캐시 할 수 있기 때문에 모든 React를 동일한 파일에 묶지 않는 것이 좋습니다.
          
+
          이상적으로 브라우저 내에서 React 모듈을 가져오지만, 대부분의 브라우저는 아직 모듈을 지원하지 않습니다.
+대신 라이브러리는 전통적으로 jQuery 나 _ 와 같은 단일 전역 변수를 사용하여 사용할 수 있습니다.
+이런 방식을 "namespace pattern"이라고 하며, Webpack을 사용하면 이 방식으로 작성된 라이브러리를 계속 활용할 수 있습니다.
+"react": "React"를 입력하면 Webpack은 React 변수에서 "react"를 불러오기 위해 마법을 사용할 것 입니다.
          
+
          여기에서 Webpack 구성에 대해 자세히 알아볼 수 있습니다.
          
 
          모든 것을 함께 모아서 (Putting it all together)
          
-
          실행 :
          
-
          webpack
+
          그냥 실행합니다:
          
+
          npx webpack
 
          
-
          이제 즐겨 찾는 브라우저에 index.html을 열면 모든 것을 사용할 준비가 될 것입니다!
          "Hello from TypeScript and React!"라고 쓰인 페이지가 보일 겁니다.
          
+
          이제 즐겨 찾는 브라우저에서 index.html을 열고 모든 것을 사용할 준비가 되었습니다!
+"Hello from TypeScript and React!" 라는 페이지가 나타납니다.
          
 
                                 
                                 
          
@@ -914,7 +984,7 @@ 
          No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"리액트 & 웹팩","level":"2.5","depth":1,"next":{"title":"기본 타입","level":"3.1","depth":1,"path":"pages/Basic Types.md","ref":"pages/Basic Types.md","articles":[]},"previous":{"title":"JavaScript에서 마이그레이션","level":"2.4","depth":1,"path":"pages/tutorials/Migrating from JavaScript.md","ref":"pages/tutorials/Migrating from JavaScript.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/tutorials/React & Webpack.md","mtime":"2019-06-14T05:32:52.262Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"../..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"리액트 & 웹팩","level":"2.5","depth":1,"next":{"title":"기본 타입","level":"3.1","depth":1,"path":"pages/Basic Types.md","ref":"pages/Basic Types.md","articles":[]},"previous":{"title":"JavaScript에서 마이그레이션","level":"2.4","depth":1,"path":"pages/tutorials/Migrating from JavaScript.md","ref":"pages/tutorials/Migrating from JavaScript.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/tutorials/React & Webpack.md","mtime":"2020-04-22T15:29:36.187Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"../..","book":{"language":""}});
         });
     
 
diff --git a/pages/tutorials/TypeScript in 5 minutes.html b/pages/tutorials/TypeScript in 5 minutes.html
index d2450035..dca5e624 100644
--- a/pages/tutorials/TypeScript in 5 minutes.html	
+++ b/pages/tutorials/TypeScript in 5 minutes.html	
@@ -481,6 +481,19 @@
             
 
             
+        
+    
+        
        • 
+            
+                
+            
+                    
+                    유틸리티 타입
+            
+                
+            
+
+            
         
          • 
     
 
@@ -627,7 +640,20 @@
             
         
     
-        
        • 
+        
        • 
+            
+                
+            
+                    
+                    프로젝트 레퍼런스
+            
+                
+            
+
+            
+        
          • 
+    
+        
        • 
             
                 
             
@@ -640,7 +666,7 @@
             
         
          • 
     
-        
        • 
+        
        • 
             
                 
             
@@ -653,7 +679,7 @@
             
         
          • 
     
-        
        • 
+        
        • 
             
                 
             
@@ -668,6 +694,26 @@
     
 
     
+        
+        
        • 릴리즈 노트
          • 
+        
+        
+    
+        
        • 
+            
+                
+            
+                    
+                    TypeScript 3.8
+            
+                
+            
+
+            
+        
          • 
+    
+
+    
 
     
        • 
 
@@ -711,60 +757,70 @@ 
          
     
                                 
          
                                 
-                                
          TypeScript로 간단한 웹 애플리케이션 만들기를 시작해봅시다.
          
+                                
          Typescript로 간단한 웹 애플리케이션을 만들어 보겠습니다.
          
 
          TypeScript 설치하기 (Installing TypeScript)
          
-
          TypeScript를 설치하는 방법은 크게 두가지입니다:
          
+
          TypeScript를 설치하는 방법에는 크게 두 가지가 있습니다:
          
 
            
-
          • NPM을 통해 설치 (Node.js 패키지 매니저)
            • 
+
          • npm을 이용한 설치 (Node.js 패키지 매니저)
            • 
 
          • TypeScript의 Visual Studio 플러그인 설치
            • 
 
          
-
          Visual Studio 2017 및 Visual Studio 2015 Update 3에는 기본적으로 TypeScript가 포함되어 있습니다.
          Visual Studio와 함께 TypeScript를 설치하지 않았다면 다운로드할 수 있습니다.
          
+
          Visual Studio 2017과 Visual Studio 2015 Update 3는 기본적으로 Typescript를 포함하고 있습니다.
+만약 TypeScript를 Visual Studio과 함께 설치하지 않았다면 이곳에서 다운로드할 수 있습니다.
          
 
          NPM 사용자의 경우:
          
 
          > npm install -g typescript
 
          
-
          첫번째 TypeScript 파일 만들기 (Building your first TypeScript file)
          
-
          편집기에서 greeter.ts파일을 만들고 다음 JavaScript 코드를 입력하세요:
          
+
          첫 번째 TypeScript 파일 만들기 (Building your first TypeScript file)
          
+
          에디터에서, greeter.ts 파일에 다음의 JavaScript 코드를 입력하세요:
          
 
          function greeter(person) {
     return "Hello, " + person;
 }
 
 let user = "Jane User";
 
-document.body.innerHTML = greeter(user);
+document.body.textContent = greeter(user);
 
          
 
          코드 컴파일하기 (Compiling your code)
          
-
          .ts 확장자를 사용했지만 이 코드는 단지 JavaScript입니다.
-기존 JavaScript 앱에서 바로 복사 / 붙여넣기 할 수 있습니다.
          
-
          명령줄에서 TypeScript 컴파일러를 실행합니다:
          
+
          .ts 확장자를 사용했지만, 이 코드는 아직 일반 JavaScript 코드입니다.
+기존의 JavaScript 앱에서 이 코드를 바로 복사하여 붙여 넣을 수 있습니다.
          
+
          커맨드 라인에서 TypeScript 컴파일러를 실행하세요:
          
 
          tsc greeter.ts
 
          
-
          결과는 동일한 자바스크립트를 포함하고있는 greeter.js 파일이 될 것입니다.
          JavaScript 애플리케이션에서 TypeScript를 실행 중입니다!
          
-
          이제 TypeScript가 제공하는 새로운 기능들을 활용할 수 있습니다.
          다음과 같이 'person' 함수의 인수에 : string 타입 어노테이션을 추가하세요:
          
+
          결과는 동일한 JavaScript 코드를 포함하고 있는 greeter.js 파일이 될 것입니다.
+JavaScript 앱에서 TypeScript를 사용하여 시작했습니다!
          
+
          이제 TypeScript가 제공하는 몇 가지 새로운 기능을 이용할 수 있습니다.
+다음과 같이 : string 타입 표기를 'person' 함수의 인수에 추가하세요.
          
 
          function greeter(person: string) {
     return "Hello, " + person;
 }
 
 let user = "Jane User";
 
-document.body.innerHTML = greeter(user);
+document.body.textContent = greeter(user);
 
          
-
          타입 어노테이션 (Type annotations)
          
-
          TypeScript의 타입 어노테이션은 함수 또는 변수의 의도된 계약을 적는 간단한 방법입니다.
          이 경우 greeter 함수를 단일 문자열 매개변수로 호출하려고 합니다.
          여기서 우리는 greeter 함수에 문자열 대신 배열을 전달하여 호출할 수도 있을 것입니다:
          
+
          타입 표기 (Type annotations)
          
+
          TypeScript의 타입 표기는 함수나 변수의 의도된 계약을 기록하는 간단한 방법입니다.
+아래의 경우, greeter 함수를 단일 문자열 매개변수와 함께 호출하려고 합니다.
+우리는 greeter 함수 호출 시 매개변수로 배열을 전달하도록 변경해 볼 수 있습니다:
          
 
          function greeter(person: string) {
     return "Hello, " + person;
 }
 
 let user = [0, 1, 2];
 
-document.body.innerHTML = greeter(user);
+document.body.textContent = greeter(user);
 
          
-
          다시 컴파일하면, 오류가 표시됩니다.
          
+
          다시 컴파일하면, 오류가 발생한 것을 볼 수 있습니다:
          
 
          error TS2345: Argument of type 'number[]' is not assignable to parameter of type 'string'.
 
          
-
          마찬가지로, greeter 호출할 때 모든 인수를 제거해보세요.
          TypeScript는 예상치 못한 매개변수로 함수를 호출했다는 것을 알려줍니다.
          두 경우 모두 TypeScript는 코드 구조와 사용자가 제공한 타입 어노테이션을 기반으로 정적 분석을 제공할 수 있습니다.
          
-
          에러가 있었음에도 불구하고, greeter.js 파일은 여전히 생성됩니다.
          코드에 오류가 있어도 TypeScript를 사용할 수 있습니다.
          그러나 이 경우에 TypeScript는 코드가 예상대로 실행되지 않을 것이라고 경고합니다.
          
+
          마찬가지로, greeter 함수 호출에서 모든 인수를 제거해보세요.
+TypeScript는 당신이 예상치 못한 개수의 매개변수로 이 함수를 호출했다는 것을 알려줄 것입니다.
+두 경우 모두, TypeScript는 코드의 구조와 타입 표기에 기반해서 정적 분석을 제공합니다.
          
+
          오류가 존재하기는 하지만, greeter.js 파일은 생성되었습니다.
+코드에 오류가 존재하더라도 TypeScript를 사용할 수 있습니다. 그러나 TypeScript는 코드가 예상대로 작동하지 않을 것이라는 경고를 하게 됩니다.
          
 
          인터페이스 (Interfaces)
          
-
          예제를 더 발전시켜 봅시다. 여기서는 firstName 및 lastName 필드가 있는 객체를 설명하는 인터페이스를 사용합니다.
          TypeSciprt에서는 두가지 타입이 내부 구조가 호환되면 호환됩니다.
          이것은 명시적으로 implements 구문 없이 인터페이스가 요구하는 형태를 가짐으로써 인터페이스를 구현할 수 있게 해줍니다.
          
+
          예제를 더 발전시켜 보겠습니다. 여기서는 firstName 및 lastName 필드를 갖고 있는 객체를 나타내는 인터페이스를 사용합니다.
+TypeScript에서, 내부 구조가 호환되는 두 타입은 서로 호환 됩니다.
+그래서 명시적인 implements 절 없이, 인터페이스가 요구하는 형태를 사용하는 것만으로도 인터페이스를 구현할 수 있습니다.
          
 
          interface Person {
     firstName: string;
     lastName: string;
@@ -776,12 +832,14 @@ 
          인터&#x
 
 let user = { firstName: "Jane", lastName: "User" };
 
-document.body.innerHTML = greeter(user);
+document.body.textContent = greeter(user);
 
          
 
          클래스 (Classes)
          
-
          마지막으로 클래스를 사용하여 예제를 확장해 보겠습니다.
          TypeScript는 클래스 기반 객체 지향 프로그래밍과 같은 JavaScript의 새로운 기능을 지원합니다.
          
-
          여기서는 생성자와 몇 개의 public 필드를 사용하여 Student 클래스를 생성 할 것입니다.
          클래스와 인터페이스가 잘 작동하여 프로그래머가 올바른 수준의 추상화를 결정할 수 있습니다.
          
-
          또한 생성자에 대한 인수에 public 을 사용하는 것은 그 이름으로 속성을 자동으로 생성 할 수 있는 단축형태입니다.
          
+
          마지막으로, 클래스를 사용하여 예제를 확장해 보겠습니다.
+TypeScript는 클래스 기반 객체 지향 프로그래밍 지원과 같은 JavaScript의 새로운 기능을 지원합니다.
          
+
          생성자와 public 필드를 사용해 Student 클래스를 만들겠습니다.
+클래스와 인터페이스가 잘 작동하여, 프로그래머가 올바른 추상화 수준을 결정할 수 있게 해준다는 점을 주목하세요.
          
+
          또한, 생성자의 인수에 public을 사용하는 것은 그 인수의 이름으로 프로퍼티를 자동으로 생성하는 축약형입니다.
          
 
          class Student {
     fullName: string;
     constructor(public firstName: string, public middleInitial: string, public lastName: string) {
@@ -794,17 +852,18 @@ 
          클래스 (Classes)
          lastName: string;
 }
 
-function greeter(person : Person) {
+function greeter(person: Person) {
     return "Hello, " + person.firstName + " " + person.lastName;
 }
 
 let user = new Student("Jane", "M.", "User");
 
-document.body.innerHTML = greeter(user);
+document.body.textContent = greeter(user);
 
          
-
          tsc greeter.ts 를 다시 실행하면 생성된 JavaScript가 이전 코드와 동일하다는 것을 알 수 있습니다.
          TypeScript의 클래스는 JavaScript에서 자주 사용되는 것과 동일한 프로토 타입 기반 OO의 줄임말입니다.
          
+
          tsc greeter.ts를 재실행하면 생성된 JavaScript 코드가 이전의 코드와 동일하다는 것을 알 수 있습니다.
+TypeScript의 클래스는 단지 JavaScript에서 자주 사용되는 프로토타입-기반 OO의 축약형일 뿐입니다.
          
 
          TypeScript 웹 앱 실행하기 (Running your TypeScript web app)
          
-
          이제 greeter.html 에 다음을 입력하세요:
          
+
          이제 아래의 코드를 greeter.html에 작성하세요:
          
 
          <!DOCTYPE html>
 <html>
     <head><title>TypeScript Greeter</title></head>
@@ -813,10 +872,16 @@ 
          </body>
 </html>
 
          
-
          첫번째 간단한 TypeScript 웹 애플리케이션을 실행하기 위해 브라우저에서 greeter.html 을 여세요!
          
-
          옵션 : Visual Studio에서 greeter.ts 를 열거나 코드를 TypeScript 플레이그라운드로 복사하세요.
          식별자 위로 마우스를 가져가면 타입을 볼 수 있습니다.
          경우에 따라 이러한 타입이 자동으로 추론됩니다.
          마지막 줄을 다시 입력하고 DOM 요소의 타입에 따라 완료 목록 및 매개변수 도움말을 확인하세요.
          greeter 함수에 대한 참조에 커서를 놓고 F12 키를 눌러 해당 정의로 이동할 수 있습니다.
          기호를 마우스 오른쪽 버튼으로 클릭하고 리팩토링을 사용하여 심볼의 이름을 바꿀 수 있습니다.
          
-
          제공된 타입 정보는 애플리케이션 규모에서 JavaScript로 작업할수 있는 도구와 함께 작동합니다.
          TypeScript에서 가능한 모든 예제는 웹 사이트의 샘플 섹션을 참조하세요.
          
-
          Visual Studio picture
          
+
          브라우저에서 greeter.html을 열어 간단한 첫 번째 TypeScript 웹 앱을 실행해보세요!
          
+
          옵션: Visual Studio에서 greeter.js를 열거나, TypeScript playground에 코드를 복사하세요.
+식별자 위에 마우스를 올려놓으면 해당 타입을 볼 수 있습니다.
+경우에 따라 타입이 자동으로 추론되기도 한다는 점을 유의하세요.
+마지막 행을 다시 입력하고, DOM 요소 타입에 기반한 완료 목록과 매개변수 도움말을 확인하세요.
+greeter 함수 참조 위에 커서를 올려놓고, F12 키를 눌러 해당 정의로 이동할 수 있습니다.
+또한, 심벌을 마우스 오른쪽 버튼으로 클릭하고 리팩토링을 사용하여 이름을 바꿀 수 있습니다.
          
+
          제공된 타입 정보는 애플리케이션 규모에서 JavaScript로 작동하는 도구와 함께 작동합니다.
+TypeScript와 관련된 더 많은 예시를 보려면, 웹사이트의 Samples 섹션을 참고하세요.
          
+
          Visual Studio picture
          
 
                                 
                                 
          
@@ -860,7 +925,7 @@ 
          No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"5분 안에 보는 TypeScript","level":"2.1","depth":1,"next":{"title":"ASP.NET Core","level":"2.2","depth":1,"path":"pages/tutorials/ASP.NET Core.md","ref":"pages/tutorials/ASP.NET Core.md","articles":[]},"previous":{"title":"소개","level":"1.1","depth":1,"path":"README.md","ref":"README.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-99001722-6"},"search":{},"addcssjs":{"css":["assets/css/atom-one-dark.css"],"js":[]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/tutorials/TypeScript in 5 minutes.md","mtime":"2019-06-14T05:32:52.263Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2019-06-14T05:59:20.233Z"},"basePath":"../..","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"5분 안에 보는 TypeScript","level":"2.1","depth":1,"next":{"title":"ASP.NET Core","level":"2.2","depth":1,"path":"pages/tutorials/ASP.NET Core.md","ref":"pages/tutorials/ASP.NET Core.md","articles":[]},"previous":{"title":"소개","level":"1.1","depth":1,"path":"README.md","ref":"README.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":["theme-darkblue","addcssjs","highlight-1","custom-favicon","forkmegithub","sitemap-general","sitemap","analytics"],"pluginsConfig":{"github":{"url":"https://github.com/typescript-kr/typescript-kr.github.io"},"analytics":{"google":"UA-163809183-2"},"search":{},"addcssjs":{"js":[],"css":["assets/css/atom-one-dark.css"]},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sitemap-general":{"prefix":"https://typescript-kr.gitbooks.io/"},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-darkblue":{},"highlight":{},"favicon":"assets/images/favicon.ico","sitemap":{"hostname":"https://typescript-kr.github.io/"},"highlight-1":{},"custom-favicon":{},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"forkmegithub":{"color":"darkblue","url":"https://github.com/typescript-kr/typescript-kr.github.io"},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"pages/tutorials/TypeScript in 5 minutes.md","mtime":"2020-04-22T15:29:36.188Z","type":"markdown"},"gitbook":{"version":"3.2.3","time":"2020-04-22T18:13:20.384Z"},"basePath":"../..","book":{"language":""}});
         });
     
 
diff --git a/search_index.json b/search_index.json
index a3e17176..b5967d3d 100644
--- a/search_index.json
+++ b/search_index.json
@@ -1 +1 @@
-{"index":{"version":"0.5.12","fields":[{"name":"title","boost":10},{"name":"keywords","boost":15},{"name":"body","boost":1}],"ref":"url","documentStore":{"store":{"./":["develop","handbook","handbook을","handbook의","java","javascript","ms측의","pr","typescript","간단한","감사하겠습니다","같은","개발을","개발자들이","검색량과","경우에는","공식","구글","규칙은","규칙을","그","기여","기초적인","깃헙","다양한","단어를","대체로","대한","됩니다.","두었습니다.","등록을","릴리즈","많이","모던하게","모든","문서","및","밖에도","버전에","번역","번역가이드","번역가이며","번역도","번역을","번역이","번역하는","번역할","번역했습니다.typescript","범위","부분과","브랜치에","사용이","사전을","상황","선정이나","소개","수","순위로","쓰이는","않는다면","어렵거나","언제나","예정입니다.","오역과","우선","의견","의미론적인","의역이","의지가","이곳을","이슈","있습니다.","있습니다.단어의","있을","저장소입니다.","전문","전문적이거나","주로","주로하는","지식과","지식이","지원되지","진행","참고하여","참고하였으며","초보","통해","페이지를","품질","피드백은","필요했었습니다.때문에","하며","한글","할","함께","해주시면","향후","홈페이지의","확인할","환영합니다:)"],"pages/tutorials/TypeScript in 5 minutes.html":["\"","\"hello,","\"jane","\"jane\",","\"m.\",","\"user\"","\"user\");","'number[]'","'person'","'string'.","(build","(classes)","(compil","(instal","(interfaces)","(node.j","(run","(type","+",".t","/","1,","2015","2017","2];","3에는","5분",":","=",">","[0,","annotations)","app)","argument","assign","class","code)","constructor(publ","document.body.innerhtml","dom","error","f12","file)","first","firstnam","firstname:","fullname:","function","g","greeter","greeter(person","greeter(person)","greeter(person:","greeter(user);","greeter.html","greeter.j","greeter.t","greeter.ts파일을","implement","instal","interfac","javascript","javascript가","javascript로","javascript에서","javascript의","javascript입니다.","lastnam","lastname:","lastname;","middleiniti","middleinitial:","new","npm","npm을","oo의","paramet","person","person)","person.firstnam","person.lastname;","person;","public","return","string","string)","string,","string;","student","student(\"jane\",","studio","studio에서","studio와","this.fullnam","ts2345:","tsc","type","typescript","typescript)","typescript가","typescript는","typescript로","typescript를","typescript의","updat","user","user\";","visual","web","{","}","};","가능한","가져가면","가짐으로써","간단한","같은","같이","개의","객체","객체를","것과","것은","것을","것이라고","것입니다.javascript","것입니다.클래스와","것입니다:","결과는","결정할","경고합니다.","경우","경우:","경우에","계약을","구문","구조가","구조와","구현할","규모에서","그","기능들을","기능을","기반","기반으로","기본적으로","기존","내부","놓고","눌러","다시","다운로드할","다음","다음을","단일","단지","단축형태입니다.","대신","대한","더","도구와","도움말을","동일하다는","동일한","될","두가지","두가지입니다:","따라","때","또는","또한","를","리팩토링을","마우스","마우스를","마지막으로","마찬가지로,","만들고","만들기","만들기를","매개변수","매개변수로","매니저)","명령줄에서","명시적으로","몇","모두","모든","목록","못한","문자열","및","바꿀","바로","발전시켜","방법은","방법입니다.이","배열을","버튼으로","변수의","보겠습니다.typescript는","보는","복사","복사하세요.식별자","볼","봅시다.","분석을","불구하고,","붙여넣기","브라우저에서","사용되는","사용자가","사용자의","사용하는","사용하여","사용할","사용합니다.typesciprt에서는","사용했지만","사이트의","새로운","샘플","생성","생성된","생성됩니다.코드에","생성자에","생성자와","설명하는","설치","설치하기","설치하는","설치하지","섹션을","속성을","수","수도","수준의","시작해봅시다.","실행","실행되지","실행하기","실행하면","실행합니다:","심볼의","안에","않았다면","않을","알","알려줍니다.두","애플리케이션","애플리케이션에서","애플리케이션을","앱","앱에서","어노테이션","어노테이션은","어노테이션을","없이","에","에러가","여기서는","여세요!","여전히","열거나","예상대로","예상치","예제는","예제를","오류가","오른쪽","올바른","옵션","완료","요구하는","요소의","우리는","웹","위로","위해","을","의도된","이","이동할","이러한","이름으로","이름을","이전","이제","인수를","인수에","인터페이스","인터페이스가","인터페이스를","입력하고","입력하세요:","있게","있는","있습니다.","있습니다.typescript의","있습니다.visual","있습니다.경우에","있습니다.그러나","있습니다.기호를","있습니다.다음과","있어도","있었음에도","있을","자동으로","자바스크립트를","자주","작동하여","작동합니다.typescript에서","작업할수","잘","적는","전달하여","정보는","정의로","정적","제거해보세요.typescript는","제공된","제공하는","제공한","제공할","줄을","줄임말입니다.","중입니다!","지원합니다.","지향","참조에","참조하세요.","첫번째","추가하세요:","추론됩니다.마지막","추상화를","커서를","컴파일러를","컴파일하기","컴파일하면,","코드","코드가","코드는","코드를","코드와","크게","클래스","클래스는","클래스를","클릭하고","키를","타입","타입에","타입을","타입이","통해","파일","파일은","파일이","패키지","편집기에서","포함되어","포함하고있는","표시됩니다.","프로그래머가","프로그래밍과","프로토","플러그인","플레이그라운드로","필드가","필드를","할","함께","함수","함수를","함수에","함수의","합니다.여기서","해당","해줍니다.","형태를","호출하려고","호출할","호출했다는","호환되면","호환됩니다.이것은","확인하세요.greeter","확장자를","확장해","활용할"],"pages/tutorials/ASP.NET Core.html":["\"./app\";","\"./app.ts\"","\"./app.ts\",","\"./main.ts\"","\"./model\"","\"./model.ts\",","\"./model.ts\"를","\"0.1.2\",","\"0.19.24\",","\"1.0.0","\"2.0.0","\"2.2.0\"","\"3.9.0\",","\"5.0.0","\"^0.6.4\",","\"angular2\":","\"angular2/core\"","\"angular2/platform/browser\";","\"compileonsave\":","\"compileroptions\"","\"compileroptions\":","\"compileroptions\"에","\"del\":","\"del\"을","\"dependencies\":","\"dependencies\"에","\"devdependencies\":","\"dom\"","\"dom\"]을","\"emitdecoratormetadata\":","\"es2015\",","\"es5\"","\"es5\",","\"excludes\"에","\"experimentaldecorators\":","\"files\"","\"files\":","\"files\"에","\"gulp\":","\"gulp\"와","\"hello","\"host","\"lib\":","\"loading...\"","\"microsoft.aspnet.iisplatformhandler\":","\"microsoft.aspnet.server.kestrel\":","\"microsoft.aspnet.staticfiles\":","\"noemitonerror\":","\"noimplicitany\":","\"nomaplicitany\"가","\"reflect","\"rxjs\":","\"sourcemap\":","\"systemjs\":","\"target\":","\"typescript\";","\"zone.js\":","${compiler}","${framework}!`;","'cjs',","'clean'작업도","'clean'작업이","'default'로","'js'","'node_modules/angular2/bundles/angular2","'node_modules/rxjs/bundles/rx.js']","'node_modules/systemjs/dist/system.src.js',","'scripts':","'scripts/**/*.map'],","'scripts/**/*.ts',","'안에","()","(.net","(add","(configur","(creat","(ctrl","(debug)","(document.getelementbyid(\"compiler\")","(document.getelementbyid(\"framework\")","(instal","(set","(test)","(updat","(write","*/","+","/*","///","1.1","1.1.2:","2","2)","2017이","2와","2의","5",":","=",">","@component({","[","[\"es2015\",","['lib'],","['node_modules/angular2/bundles/angular2.js',","['scripts/**/*.js',","]","],","`hello","`mi","angular","angular가","app","app)","app.ts에","app.ts의","app.usedefaultfiles();","app.useiisplatformhandler();","app.usestaticfiles();","app`,","applic","asp.net","beta.11\",","beta.2\",","bootstrap(myapp);","breakpoint가","breakpoint를","browse.","build)","c#","class","cloud\"","code)","compil","compiler)","compiler:","configur","configurationfile을","configure(iapplicationbuild","configure를","console.error.bind(console));","const","core","core)","core를","debugg","default","defaultextension:","del","del(['wwwroot/scripts/**/*']);","depend","dependencies)","dependencies에","devdepend","div가","edge에서","empti","empty를","entri","es2015에","es2015에서","exampl","explorer가","explorer를","export","f12","file","file을","final\"","final\",","format:","framework","framework:","function","getcompiler()","gulp","gulp)","gulp.src(paths.libs).pipe(gulp.dest('wwwroot/scripts/lib'));","gulp.src(paths.scripts).pipe(gulp.dest('wwwroot/scripts'))","gulp.src(paths.scripts).pipe(gulp.dest('wwwroot/scripts'));","gulp.task('clean',","gulp.task('default',","gulp.task('lib',","gulpfile.js라는","gulpfile.js를","gulpfile.js은","gulpfile을","gulp의","html","htmlinputelement).value;","http://go.microsoft.com/fwlink/?linkid=518007","import","index.html에","index.html의","index.html이라는","item을","javascript","javascript파일을","js를","lib","libs:","lib에","loading...","localhost","main.ts라는","manag","metadata\":","microsoft.aspnetcore.staticfil","model","model.ts라는","myapp","mymodel","mymodel();","n)","new","npm","npm)","npm3에서","npm을","nuget","open","packag","package.json을","package.json의","packages:","packages를","page)","path","peer","point입니다.","polyfills.js',","project)","project.json에서","promise과","public","rc1","require('del');","require('gulp');","restor","return","runner","sayhello()","scripts/app.ts를","scripts:","scripts라고","scripts를","scripts에","selector:","server)","shift","simpl","startup.cs에서","studio는","studio에","studio에게","system.config({","system.import('scripts/main').then(null,","systemjs를","task","template:","this.model.compiler;","true","true,","true를","tsconfig.json","tsconfig.json)","tsconfig.json를","tsconfig.json을","type","typescript","typescript\"","typescript)","typescript가","typescript를","typescript에","typescript의","up","usedefaultfiles와","usestaticfil","var","visual","visualstudio2015","visualstudio에","void","vs2015","vs2015의","vs2017","vs2017의","vs를","web","wwwroot","wwwroot에","{","{bootstrap}","{component}","{myapp}","{mymodel}","{{getcompiler()}}`","}","})","});","},","};","—","가이드를","가져오려면","간단한","같습니다:","같아야","같은","같이","검사가","검색","것들에는","것은","것이므로","것입니다","것입니다.","경로.","경우","경우는","경우에는","교체합니다.","그","그냥","그러면","그런","그리고","기본","기본값과","기본이","기본적인","끝난","나열합니다.","나열해야","내용을","누르고","다른","다시","다운로드할","다음","다음과","다음으로","단계는","대신","대체하세요:","대한","데코레이터가","데코레이터에","될","들어가고","디버그","때","때마다","때문에","또","또는","라이브러리","라인에","라인이","로드됩니다.asp.net","로컬에서","를","리스트","리스트를","마우스","마지막으로","만들","만들기","먼저","메시지가","명시적으로","및","방법을","버튼으로","번째","변경하십시오","보게해야","보려면","보일","복사해야","부르겠습니다.","빌드","빌드가","빌드를","빌드에","빌드의","빨간선이","사라지려면","사용","사용되지","사용하기","사용하십시오.","사용합니다","사항은","상자에","새","새로고침","새로운","서버","선언을","선택","선택을","선택하고","선택하세요.","설정","설정은","설정합니다","설정합니다.","설정해야","설치","설치되었으므로","설치를","설치할","설치합니다.이","섹션에","손쉽게","수","수도","스타트","시작해야","실수로","실행","실행됩니다.","실행하고","실행하기","실행하도록","실행하면","실행하십시오.","실험적","쓰지","아래의","아직","안에","않고","않도록","않으면","않으므로","않은","않을","알려줘야","알아야","애플리케이션","애플리케이션을","앱에서","앱을","앱이","앵귤러","업데이트","업데이트된","업데이트할","없는","에","여기를","연결(pipe)","예제","오른쪽","올바르게","요청하면","웹","위한","위해","위해서는","유사합니다.","의존성","의존성으로","의존성은","의존성을","의존성이","의존하지","이","이것뿐입니다.다음으로","이라고","이러한","이를","이름","이름을","이름의","이름인","이제","일부로","입력","입력하고","입력하십시오","입력할","입력합니다.","있는","있도록","있습니다","있습니다.","있습니다.\"compileonsave\"는","있을","있음)을","자세한","작동하는지","작성","작성할","작성합니다.","작업을","저장하는","저장한","정리하도록","정의하고","제외하고","좋습니다","준다.","줄은","중인","즉시","지시합니다.또한","지원이","지정되지","지정합니다.","직접","차이점을","찾습니다.","찾은","첫","최신","추가","추가하는","추가하십시오","추가하십시오.","추가하십시오.그런","추가하여","추가할","추가합니다","추가합니다.","추가해야","취소합니다.","컴파일러","코드","코드를","코드에","코어","퀵","클릭하고","클릭하십시오.","클릭하십시오.'default'","클릭하십시오.그런","클릭합니다.그런","키를","타입스크립트","타입이","탐색기를","태스크를","태스크에","탭을","테스트","파일","파일에","파일은","파일을","파일이","패키지를","페이지","포함시키기","폴더를","표시되지","표시된","표시됩니다","표시됩니다.","프로젝트","프로젝트를","프로젝트에","플러그인을","필요하지","필요한","필요합니다.","필요합니다.또한","하십시오.","한번","할","합니다","합니다.","합니다.script","합니다.tsconfig는","합니다.그렇지","합니다.프로젝트를","합니다.향후에는","항목을","해","확인합니다.","후에","후에는"],"pages/tutorials/Gulp.html":["\"./greet\";","\"compileroptions\":","\"es2015\"","\"es5\"","\"files\":","\"hello","\"noimplicitany\":","\"src/greet.ts\"","\"src/main.ts\"","\"src/main.ts\",","\"target\":","\"typescript\");","${compiler}`);","${name}`;","'.',","'copi","'default'","'default'...","()","(0.02","(0.05","(0.13","(1)과","(2)는","(add","(creat","(initi","(instal","(minim","(test","(unix","(write","...","./dist/main.js를",".bundle()",".es,",".es6",".js,",".js.pipe(gulp.dest(\"dist\"));",".jsx",".pipe(buffer())",".pipe(gulp.dest(\"dist\"));",".pipe(gulp.dest('dist'));",".pipe(source('bundle.js'))",".pipe(sourcemaps.init({loadmaps:",".pipe(sourcemaps.write('./'))",".pipe(tsproject())",".pipe(uglify())",".plugin(tsify)",".t",".transform('babelify',","1.36","2261","26","2808","2824",":","=","[","[\"copi","['.ts']","['copyhtml'],","['es2015'],","['src/*.html']","['src/main.ts'],","[10:34:20]","[10:34:21]","[10:35:22]","[10:35:24]","],","`hello","app)","babel","babel,","babelifi","babelify는","babelify도","babelify를","babelify에","babel은","babel의","basedir:","browserifi","browserify({","browserify,","browserify가","browserify를","browserify에","browserify의","buffer","buffer');","buffer와","bundl","bundle()","bundle);","bundle);을","bundle.js가","bundle.js의","bundle을","byte","cache:","cat","cd","cli","cli를","code)","commonj","commonjs를","console.log(`hello","console.log(sayhello(\"typescript\"));","const","copi","core","debug","debug:","default","default를","default의","dependencies)","dev","dist","dist/","dist/bundle.j","dist/index.html을","dist/main.j","dist에서","document.getelementbyid(divname);","elt","elt.innertext","entries:","es2015","es2015도","es3으로","es5","es5를","example)","export","extensions:","finish","function","g","greet.ts를","greet.ts에서","gulp","gulp.src(paths.pages)","gulp.task(\"copi","gulp.task(\"default\",","gulp.task('copyhtml',","gulp.task('default',","gulpfil","gulpfile.j","gulpfile.js)","gulpfile을","gulp로","gulp를","gulp에서","gulp을","gutil","gutil.log);","gutil.log);을","hello","hello(\"typescript\");","hello(compiler:","html","html\",","html\"],","html'","html'...","html이","import","index.html","init","instal","install을","javascript","load","main.t","main.ts를","mkdir","modul","module을","ms","name:","node","node.js는","node가","npm","option","packagecache:","page)","pages:","paragraph","path","point를","preset","presets:","preset을","proj","proj$","proj/","project)","proj라고","proj이라는","require(\"browserify\");","require(\"gulp","require(\"gulp\");","require(\"tsify\");","require(\"watchify\");","require('browserify');","require('gulp","require('gulp');","require('tsify');","require('vinyl","result","return","s","save","sayhello","sayhello(name);","sayhello(name:","sayhello를","seconds)","showhello","showhello(\"greeting\",","showhello(divname:","showhello에","simpl","sourc","source(vinil","sourcemap","sourcemaps');","sourcemaps도","sourcemaps에","sourcemaps이","src","src/","src/greet.t","src/greet.ts를","src/main.ts의","src에","start","stream","stream');","stream에","stream을","string)","string,","sudo를","true,","true}))","true를","ts","ts.createproject(\"tsconfig.json\");","tsconfig.json","tsconfig.json에","tsconfig.json을","tsifi","tsify는","tsproject","tsproject.src()","typeifi","typescript","typescript!\"를","typescript\");","typescript\"가","typescript,","typescript는","typescript를","typescript에서","typescript와","typescript의","typescript처럼","uglifi","uglify');","uglify는","uglify를","us","util","util\");","var","vinyl","vinyl으로","watchedbrowserifi","watchedbrowserify.on(\"log\",","watchedbrowserify.on(\"update\",","watchifi","watchify(browserify({","watchify,","watchify가","watchify로","watchify를","watchify에","world","world!","written","{","{}","{},","}","})","}).plugin(tsify));","});","};","~/src/proj/gulpfile.j","—","└─","├─","가","가이드는","가정합니다.","가져오도록","가지","간단한","감싸고","같은","같이","개발자","객체를","객체에","걸프","것에","것은","것을","것이므로","것입니다.","것입니다.entri","것입니다.즉","결과를","경우","계속","고침","골격으로","광범위한","구문을","구조입니다.","구조화해야","그","그런","글로벌","기능에","기능을","기본값을","기본적으로","끝납니다.","난독화로","내보내는","내보냅니다.소스","내에서","넣으면","노드에서","다시","다양한","다운로드","다음","다음과","당장은","대로","대상","대신","대한","데","돌아가서","동일한","될","둘","디렉토리부터","디버거를","디버깅","디버깅하는","디버깅할","때","때마다","때문에","또는","또한","라인에","로그했습니다.","로깅을","루트에","리팩토링해야합니다.","마지막으로","만들고","만들기","만듭니다","맞춤형","매우","맵","맵을","맵이","먼저","명령","모두","모듈","모듈을","모듈이","모든","묶어서","믹스에","및","바꿀","받게","방법을","방식으로","방출했습니다.이","백그라운드","번들","번들로","번들링","변경","변경되지","변경될","변경하고","변경하십시오","변경하여","변경할","변경합니다","변경합니다.이제","변경했습니다.편리하게도","변환을","변환하는","변환할","별도의","별칭)를","보겠습니다.","보겠습니다.이것은","붙여야","붙이겠지만","브라우저로","브라우저에서","브레이크포인트가","브레이크포인트을","빌드에","빌드한","사용하겠지만","사용하고","사용하기","사용하는","사용하면","사용하여","사용한","사용할","사용합니다.package.json","사용했지만","사이클을","사항이","사항이지만","새로","새로고침","새로운","생성","생성합니다","생성합니다.","선택","설정을","설정이","설정하여","설치","설치하십시오","설치하십시오.gulp","설치하십시오.tsify는","설치하십시오.uglify의","설치하십시오.uglify처럼","설치할","설치해야","세","소스","소스맵을","수","수도","수정합시다","쉬운","스크립트에","스타트","시간을","시스템을","시작하겠습니다","시작하기","시작하려면","시작하여","시작합시다.","시작해야","실제","실행되고","실행되어야","실행될","실행됩니다.main.ts에서","실행하고","실행하도록","실행하며","실행하면","안에","않는","않은","알려줍니다.","알림을","압축되는지","압축하기","압축합니다.","앞에","앱","앱에서","약간","언제든","업데이트하십시오","엉망으로","여기에는","열고","열어","예제","옵션으로","요점은","원본","원하는","위한","위해","유사해야","유연한","유용합니다.","유지하려면","유지했습니다.","의미합니다.","의미합니다.watchify와","의미합니다.또한","의존성","의존성에","의존성으로","이","이것을","이동하겠습니다.이를","이를","이름을","이미","이상을","이전과","이제","이제는","인","인라인","인쇄해야합니다.","인스턴스를","인식하는","인해","일련의","일시","일입니다.더","있는","있다고","있다는","있도록","있습니다","있습니다).","있습니다.","있습니다.먼저","있습니다.브라우저의","있습니다.이제","있습니다.페이지를","있으며","있지만","자체에는","작동하는지","작성","작성해","작업에서","작은","저장","저장하십시오.","저장할","전달할","전송되는","전에","전용","점차적으로","접근할","정확히","제공된","제외하고는","존재합니다.이러한","좋은","주목하십시오.이로","주어야","줄이도록","중","중지하고","지원하지","지정한","지정합니다.","진행할","처리하므로","초기화","추가","추가하고","추가하는","추가하십시오","추가할","추가합니다.default가","추가합니다.npm과","추가해","추가해야","출력","출력과","출력은","출력을","출력이","컴파일러를","컴파일러에","컴파일러입니다.따라서","컴파일을","컴파일합니다.이를","코드를","코드에","코드에서","콘솔에","퀵","태스크를","테스트","테스트하십시오.페이지에","테스트하여","테스트할","텍스트를","통해","튜토리얼에서는","파이프","파일","파일로","파일만","파일은","파일을","패키지로","패키지를","페이지","페이지를","편집","폴더를","폴더에서","표시되어야","프로그램에서","프로그램을","프로젝트","프로젝트를","프로젝트의","플러그인으로","플러그인을","플러그인입니다.","플러그인입니다.vinyl","필요합니다.babel은","필요합니다.기본적으로","하고","하고자","하기","하나가","하나의","하는","한다는","할","함께","함수를","함수에","합니다","합니다.","합니다.(3)을","합니다.다행히도","합니다:","해야","했습니다.","했으므로","형식으로","호출만","호출에서","호출은","호출을","호출하도록","호출하여","호출한","호출해야","확인하기","확인하십시오","확장자가","확장자를","후"],"pages/tutorials/Migrating from JavaScript.html":["!array.isarray(arguments[1]))","!를","\"./built\",","\"./dist/bundle.js\",","\"./src/**/*\"","\"./src/index.ts\",","\".js\"]","\".ts\",","\".tsx\",","\".web.js\",","\".webpack.js\",","\"allowjs\":","\"awesom","\"compileroptions\":","\"es5\"","\"include\":","\"outdir\":","\"red\",","\"red\";","\"sourc","\"target\":","&","&&","'.js'","'.ts'","'.tsx'","'.tsx'를","'awesom","'define'.","'foo!'에","'foo'.과","'foo'는","'null'일","'require'.와","'sourc","'string[]'타입이","(allowj","(any,","(arguments.length","(earli","(export","(get","(import","(includ","(integr","(move","(no","(number를","(outdir와","(sequenti","(set","(strict","(target","(too","(weed","(write","(x:","(또는","**","+","...","...nums:",".j",".tsx로",".ts로","/","//","/\\.js$/,","/\\.tsx?$/,","/undefined라고","0,","0});","1,","11","11;","2","2);","2,","3,","4);","4]);","5",":","=","==","=>","@types/lodash","[","[\"\",","[1,","]","],","ad","allowunreachablecode와","allowunusedlabels로","amd","any)","any;","any[]):","any가","any는","any를","any와","app","argument","arguments)","arguments[0];","arguments[1];","arr","assertion)을","awesom","babelifi","babel과","benefits)","break문을","browserify와","build","built","builtd에","case","check","checks)","class","code나","color:","color에","commonjs가","configur","console.log(x)","constructor(publ","convers","declar","define(...args:","define([\"foo\"],","devtool:","directories)","dist","distancefromorigin(point:","dx","dy","ecmascript","entry:","errors)","export","express","express();","extensions:","f","feedpets(pets)","few","file)","file1.j","file2.j","filename:","files)","find","foo","foo!.length;","foo()","foo.dostuff();","foo.length;","foo:","foo;","function","function(foo)","function(pets)","function(point:","function(this:","get","getdistance(p:","getdistance의","guide를","gulp","gulp를","implicit","import","import에","instal","interfac","javascript","javascript가","javascript로","javascript에서","javascript와","jsx를","lib","loader","loader\"","loader'로","loader'에","loader:","loaders:","loader도","loader를","loader와","lodash를","lodash와","many/too","map","map\",","math.sqrt(dx","modul","module.export","module.exports.feedpet","module.exports와","module:","moduleresolut","modules)","mycoolfunction()","mycoolfunction(f:","mycoolfunction(function(x)","mycoolfunction가","mycoolfunction에","mycoolfunction이","name","no!","node/commonj","node/commonjs를","node로","noemitonerror","nofallthroughcasesinswitch는","noimplicitani","noimplicitany를","noimplicitreturns는","noimplicitthi","npm","null","null;","null과","null로","number","number(이)거나","number)","number;","number[]):","number의","nums:","object","object,","object가","object보다","object와","option","options.color","options.volum","options;","options에","options의","out","output:","p.i","p.x","point","point)","point):","point,","point.prototype.distancefromorigin","point:","preloaders:","pretty를","projectroot","properties)","public","react","require(\"express\");","require(\"foo\");","require(path:","requirej","requirejs/amd를","resolve:","return","s","sourc","src","src에","src와","src의","stricter","strictnullcheck","strictnullchecks가","strictnullchecks도","strictnullchecks를","string):","string;","string[]","studio","switch블록","test","test:","tests에","this)","this.getdistance({","this.x;","this.y;","this를","this의","tolowercase()와","tools)","true,","ts","tsc","tsconfig.json","tsconfig.json와","tsconfig.json이라는","tsc를","ts로","typescript","typescript가","typescript는","typescript로","typescript를","typescript에","typescript에서","typescript에서는","typescript의","uglify와","umd입니다.","undefin","undefined는","undefined이","union","up","var","visual","void,","void;","volume:","volume과","webpack","webpack.config.j","webpack에","webpack을","webpack의","word와","x,","x:","y)","y:","{","{}","{})","{};","{}가","{}로","{}를","{}을","|","}","})","},","};","│","└──","├──","가능성이","가능한","가장","가정할","가정합니다.","가정합니다.즉","가져","가져오기","가져올","가지","가지고","가지를","가진","가질","가집니다.","각","각각의","간단한","간단합니다.","값에","값을","갖는)","갖습니다.","갖지","갖춰야","같은","같이","같지만","개의","객체","객체를","걱정을","검사","검사는","검사를","검사의","것과","것들을","것으로","것은","것을","것이","것이고","것이든","것인지를","것입니다.","것입니다.각","것입니다.다행히도","것입니다.대신","것입니다.이는","것입니다.종종","것입니다.첫","것입니다.파일이","것입니다:","것처럼","결정하는","결정할","결합하여","경고가","경고를","경고합니다.이","경우","경우:","경우가","경우에는","계획이라면","곳에서","공백","관대하기","관리합니다.프로젝트에","관한","구문을","구성하고","구조가","구조로","그","그냥","그러면","그런","그레이션에는","그리고","기록하도록","기본적으로","기본적인","기술적으로","꽤","끝냈나요?","끝에","나","나머지","나은","나타날","나타납니다.","내","내보내기","내보내기는","내보낸","너무","너무나","높습니다.","높일","누릴","느껴질","느슨하면","다루기","다루는","다르게","다르지만","다른","다소","다시","다음","다음과","다음의","다할","단계가","단계는","단계를","단언(type","대로","대부분의","대신","대체로","대한","대해","대해서도","더","덜어주기","덮어쓰기도","덮어쓰지","도구","도구는","도구를","도구와","도구의","도달","동안","동일한","동일해야","된","될","됩니다.","됩니다.js에서","됩니다:","두","두고","두번째는","둘의","뒤에","들어","디렉토리","디렉토리가","디렉토리에","디렉토리에의","디버깅","디버깅이","때","때가","때는","때때로","때로는","때문에","또는","뛰어난","라벨에","라벨은","라이브러리를","라인에","레벨","레이아웃과","레이아웃은","로더보다","로더인","루트에","리터럴","리터럴에","마이","마이그레이션","마찬가지입니다.여기에서.","만들기","만들어졌으며","만약","만큼","많거나","많은","말할","매개","매개변수(...nums)를","매개변수를","매우","맵을","맵이","먼저","메서드로","메서드를","메시지가","명령문을","명시적(또는","명시하려면","명확한","몇","모델링할","모듈","모듈로","모듈에서","모듈을","모든","모르는","목록을","못한","무언가를","묵시적인","문서를","문제는","문제를","문제없는","문제없이","물론","및","바꾸는","바꿔야","바로","밖에","밖에서","반환문을","받기","받을","발견할","발생으로","발생하기","발생하는","발생하지","발생할","발생합니다.","방법에","방법을","방법이지만","방식으로","방지합니다.","버그가","버그를","버그의","버그이지만","버리게","버전으로","벅차다고","번들링이나","번째","범위에","베이스를","변수를","변환","변환하는","변환하려는","변환한","변환합니다","변환합니다.","병합하십시오","보냅니다","보통","볼","분리해야","분석을","불평하는","비밀스러운","빌드","빨간","빨리","빼먹는","뻬먹지","뼈대를","사람들은","사용","사용)","사용되며","사용하고","사용하기","사용하기로","사용하는","사용하도록","사용하려는","사용하면","사용하여","사용한다면","사용할","사용합니다.","사이에","살펴보겠습니다.새로운","살펴보고","상태로","상황에서","생각하는","생각하여","생각하지","생각해야합니다.word에서","생성된","생성하겠습니다:","생성하고","생태계를","선언","선언된","선언을","선언했을","선호해야","설명할","설명해야","설정","설정되어","설정되었다고","설정을","설정하기","설정하는","설정하면","설정하여","설정합니다.","설정해야","성공적으로","소스","속성을","수","수도","수없는","수정하기","수행할","순차적으로","숫자여야","쉬운","쉬워","쉽습니다.typescript에서","스크립트가","시스템을","시작하는","시작하면","시작할","시점에서도","실제로","실행","실행하게","실행하고","실행하려고","실행하면)","실행할","실행해야","쓰는","쓰면","아닌","아닙니다.중요한","안전도","안전성과","안전성을","않기","않는","않다는","않도록","않습니다.javascript","않습니다.이","않습니다:","않을","알게됩니다:","알고","알려주어야","알리기","암시적인","앞서","어떠한","어떤","어떻게","어렵지","언급","언급한","얻을","엄격하게","엄격한","엄격함을","업데이트해야","없다고","없습니다.","없습니다.typescript에서","없으며","없이","여기서","여전히","연결했을","연산자","열면","열어보세요","염두에","예를","예상치","예술적으로","오기","오는","오늘날에는","오류","오류가","오류를","오버로드를","옮기면","옳다고","옵션들...","옵션으로","옵션은commonjs,amd,system","옵션을","완성과","완성을","완전히","요점을","원래","원천이기","원치","원하는","위에서","위치를","위한","위해","유연한","유용하지만","유용합니다.","유형의","을","의미에서","의미하지만","의미합니다.","의존성을","의해","이","이것들은","이것은","이것을","이동","이득은","이득이","이때","이러한","이런","이렇게","이름을","이미","이에","이와","이유로","이전","이전에는","이점을","이해함으로써","인쇄할","인수","인수가","인수를","인터페이스나","인터페이스를","인해","일","일반적이라는","일반적인","일부","일이","읽습니다","읽어볼","읽은","읽을","잃어","입력","입력으로","있게","있고","있는","있다.","있다고","있다면","있습니다","있습니다.","있습니다.microsoft","있습니다.typescript를","있습니다.v","있습니다.가능하면","있습니다.그런","있습니다.그렇기","있습니다.다소","있습니다.또한","있습니다.아마도","있습니다.여기서","있습니다.예를","있습니다.이","있습니다.이러한","있습니다.이런","있습니다.전형적으로","있습니다.하지만","있습니다:","있어야","있으며","있을","있음을","있지","있지만","자동","자리에","자주","자체로","자체에","작성하게","작성하기","작성하기에","작성하는","작성한","작성할","작성해보세요","작성했을","작업해야","잘","잡기","장기적","적다는","적은","전에","전형적으로","전환하기","점에","점에서","정의하고","제거하고","제공하기","제공하는","제공합니다.일단","조금","조작할","조절할","존재하지","존재합니다.javascript","좀","종류와","좋습니다.","좋습니다.(아래의","좋아요","좋았어!javascript에서","주의해야","준비가","줄을","줄이","중","중간","즉시","즐겁다는","지금","지금부터","지루하지만","지시하고","지원을","지원하는","지정합니다:","직접","집니다.","차이점에","참고로","참조).","참조하는","찾아냈기","처리된","처리됩니다.","처리할","철자가","첫","체크","초기의","최상위","최선을","최신","추가","추가되는","추가하고자","추가하는","추가합니다.","추가했습니다.","추론된)","추론하지","출력","출력에는","출력을","충분한","컴파일하는","코드","코드:","코드를","코드와","코드처럼","클래스","클래스를","키워드를","타이프","타입","타입에","타입으로","타입을","타입의","타입이","타입이기","타입이라고","타입이어야","타입인","타입입니다.","통합","통합됩니다.거기서","통합은","통해","튜토리얼에서","튜토리얼에서는","튜토리얼이","트랜스파일러를","특별합니다.즉","특정","특정한","틀리거나","파이프","파일","파일(declar","파일과","파일로","파일에","파일은","파일을","파일의","파일이","판결났다면","패키지에","패턴입니다:","편집기","편집기로","편집기에서","평범한","포함)","포함시킬","포함할","포함합니다.typescript를","폴더","폴더가","표시되는","표시됩니다.built에","표시할","프로그램의","프로젝트","프로젝트를","프로젝트에서","프로젝트의","프로퍼티","프로퍼티도","프로퍼티를","플래그를","하나씩","하나의","하는","하면","한","한다는","할","할당할","할지","함께)","함수","함수도","함수를","함수에","함수의","합니다.","합니다.webpack을","합니다.그것들은","합니다.유효한","합니다.이제","합니다.출력","항목이","해결책은","해당","해제할","핸드북을","했습니다!","허용할","허용합니다","허용해준다는","혜택","호출","호출될","호출들은","호출하여","호출할","혹시","확보할","확실할","확인","확장자로","확장자를","활성화되면","활성화하여","활성화해야","후에","후에는","후위","훨씬"],"pages/tutorials/React & Webpack.html":["\"./components/hello\";","\"./dist/\",","\"./src/**/*\"","\"./src/index.tsx\",","\".js\",","\".json\"]","\".tsx\",","\"/dist\"","\"awesom","\"bundle.js\",","\"commonjs\",","\"compileroptions\":","\"es5\",","\"include\":","\"jsx\":","\"module\":","\"noimplicitany\":","\"outdir\":","\"pre\",","\"react","\"react\"","\"react\",","\"react\":","\"react\";","\"react\"를","\"react\"에","\"react\"와","\"reactdom\"","\"sourc","\"sourcemap\":","\"target\":","\"네임","&","'.js'","'.ts'","'.tsx'","'.tsx'를","'awesom","'helloprops'는","'sourc","'{}'타입을","(add","(creat","(initi","(instal","(lay","(props:","(put","(write",");","*","+",",","..",".j","/","//","/\\.js$/,","/\\.tsx?$/,",":","=","=>","@types/","@types/react","[","[\".ts\",","]","__dirnam","_와","awesom","bundle.j","cd","cdn","cdn을","class","code)","compiler:","compon","components/","components를","configur","const","dependencies)","dev","develop","devtool:","dist","dist/","dist의","document.getelementbyid(\"example\")","dom","dom\":","dom\";","dom\"과","dom을","dom의","enforce:","entry:","entry를","export","extend","extensions:","extern","externals:","file)","filename:","framework:","function","g","guide를","hello","hello.tsx라는","hello.tsx에","helloprop","helloprops)","import","index.html을","index.html파일을","index.tsx로","index.tsx를","init","instal","interfac","jqueri","link","loader","loader\"","loader'로","loader'에","loader:","loader가","loader는","loader를","loader에","loader와","map","map\",","mkdir","module.export","module:","node.js를","node_modules에서","npm","npm과","out","output:","package.json","path:","proj","proj/","project)","proj로","proj의","props의","quick","react","react!","react!\"라고","react.compon","reactdom","reactdom.render(","react를","react와","react의","render()","resolve:","return","rules:","save","sourc","src","src/","src에","start","stateless","state가","string;","test:","time","together)","true,","ts","tsconfig.json","tsconfig.json을","tsconfig.json이라는","typescript","typescript는","typescript로","typescript를","typescript와","typescript의","webpack","webpack.config.j","webpack에","webpack으로","webpack은","webpack을","webpack의","webpack이","{","{props.compiler}","{props.framework}!;","{this.props.compiler}","{this.props.framework}!;","}","},","};","└─","├─","가능한","가르쳐줄","가이드에서는","가정하고","가정합니다.","가져","가져오고","가져온다는","가져왔습니다.\"react\"","가지","가진","같은","같이","개발","걸","겁니다.","것","것은","것을","것이","것입니다!\"hello","것입니다.","결국","경로가","경로를","경우","경우에","경우입이다.","계속","고급스럽게","골격으로","구성","구성해야합니다:","궁금해","그런","그렇지","글로벌","글로벌으로","기본값을","끝납니다.작성된","나","내용은","내용을","다","다른","다시","다음","다음과","다음으로","단","달리","담은","대부분의","대비하여","대신","대신node_modul","대한","대해","더","데","도구입니다.","도움이","독립적인","동일한","될","됩니다.sourc","됩니다:","두","둘","들어갑니다.","디렉토리를","디렉토리부터","디렉토리에","디버깅","때","때문에","또는","또한","라이브러리","라이브러리는","라이브러리를","로더","로더는","루트에","리액트","마술을","만들","만들고","만들기","만듭니다.","만듭니다:","맵","맵을","맵이","먼저","몇","모두","모듈을","모든","모릅니다.이렇게","모아서","목록이","묶는","및","바꿀","방법을","방식으로","방지합니다.","배치","버전을","번들(묶어서)로","번들로","번들링(묶는)하는","번들링하는","번째","변경하지","변경할","변수가","변수에서","보겠습니다.먼저src/components에","보았을","보여줄","보일","복사하거나","볼","봅시다","불러오기","브라우저가","브라우저들은","브라우저에","브라우저에서","빌드와","빠르게","뿐이지만","사본에","사용자의","사용하고","사용하는","사용하도록","사용하면","사용하세요.","사용하여","사용할","사용합니다.","사용했음을","사이에","사이의","살펴","살펴보세요.","살펴봅니다.그러나","상대","새","새로운","생각할","생성","생성된","생성할","생성해","생성해야","선언","선택적으로","설정","설정과","설정되어","설정에","설정합니다.","설치","설치되어","설치했음을","소스","수","수도","스페이스","시간이","시작하려면","시작한","시작합시다.","실행","실행하여","싶다면","쓰인","아니라","아니므로","아닙니다.대신","아마도","아직도","않다면","않습니다.대신","않아","않으면","않은","않을","알게","알립니다.이렇게하면","언제든","없다는","여기를","여기에서","연결할","열면","예제를","예제에서는","오면","완전히","요소는src","원래","원하는대로","웹","웹팩","위한","위해","유일한","의미합니다.일반적으로","의존성","의존성으로","의존성을","의해","이","이것은","이것을","이는","이러한","이렇게","이름을","이름의","이미","이상적으로는","이제","일반적으로","일에","일치하는","읽어보세요.","임포트","임포트하는","입니다.awesom","입력","있게","있기","있는","있는지","있다고","있습니다.","있습니다.사용자를","있습니다.여기에서","있었는데","있으며이를","있으므로","있음을","있지","자세한","자유롭게","자체","자체를","자체적으로","작동하도록","작성","작성된","작성하세요.","작성할","작성합니다:","작성해","잘","전통적으로","접두사는","제공하고","제공하며","좀","종속성을","좋습니다.페이스북은","주목하세요","주목하십시오.react와","주목하십시오.typescript를","주의사항이","준비가","중","중요합니다.","중요합니다.그렇지","즐겨","증가하고","지금은","지원하지","지정했지만","직접","차이점에","참조하고","참조하십시오.","찾는","찾습니다.나중에는","채우기만","처리된","처리됩니다.","첫","초기화","최종","추가","추가하겠습니다:","추가할","추가합니다.","출력","출력에는","출력을","캐시","컴파일","컴파일하는","컴포넌트를","코드","코드를","통해","파일","파일로","파일뿐만","파일에","파일에서","파일은","파일을","파일의","파일이","패키지","패키지가","패키지로","패키지를","패키지에는","패턴\"이라고","페이지가","페이지에","포함되어","포함된","포함하고","포함하는","포함할","폴더를","폴더에","폴더에서","표시되지만","표준","프로젝트","프로젝트를","프로젝트의","피할","필드에","필요도","필요한","필요합니다.다음과","하게","하나와","하나의","하듯이","하려면","하며","하면","할","할지도","함께","합니다.프로젝트","합니다:","해당하는","해주는","했습니다.이를","형태을","호스팅","호스팅하는","확인","확인해보세요.","확장자로","확장자를","활용할","후","흔치"],"pages/Basic Types.html":["\"","\".\\n\\n\"","\"angl","\"blue\";","\"free\"];","\"hello\"];","\"hello,","\"i'll","\"thi","\"world\";","\"나를","\"문자열일수도","${","'boolean'은","'green'을","'number'에","'number'은","'object'","'red';","'string","'string'","'string'은","'substr'을","'tofixed'","'tostring'이","(`","(age","(array)","(boolean)","(enum)","(introduction)","(never","(number)","(opt","(somevalu","(somevalue).length;","(string)","(true)","(tuple)","(type","(union","(그러나","(꺾쇠괄호)",")","+","/","//","0","0b1010;","0o744;","0xf00d;","0부터","1","1)","1,","100;","10];","10진수","16진수와","1로","2","2,","2를","2진수","37;","3];","4;","4}","6;","8진수",":","=","[\"hello\",","[1,","[10,","[]","[string,","`bob","`hello,","ag","age:","alert(\"thi","alert(colorname);","any[]","any의","array","array:","assert","assertions)","assertions은","assertion은","binary:","blue","blue}","bobbington`;","boolean","bracket\"","c:","color","color.green;","color:","color[2];","colorname:","console.log(x[0].substr(1));","console.log(x[1].substr(1));","console.log(x[5].tostring());","decimal:","ecmascript2015에","end","enum","enums는","enum에서","enum은","enum의","error(\"someth","error(message);","error(message:","fail()","failed\");","fals","false;","fullnam","fullname:","function","green","green,","hex:","i'll","ifitexists가","in)","infiniteloop():","isdone:","javascript","javascript가","javascript로","javascript에서","javascript와","javascript의","jsx와","let에","let을","let의","list:","list[1]","message\");","month.\";","month.`;","n:","name","never","never는","never를","never에","never의","new","next","notsur","notsure.ifitexists();","notsure.tofixed();","notsure:","null","null;","null과","null은","null이라는","number","number'","number'에","number[]","number];","number와","number의","numer","object","octal:","old","out)","point가","prettysure.tofixed();","prettysure:","return","sentence:","somevalue:","strictnullcheck","string","string\";","string).length;","string):","string과","strlength:","throw","tofixed는","true","true,","true;","type","typescript","typescript가","typescript는","typescript를","typescript보다","typescript에서","typescript에서는","typescript의","u:","undefin","undefined;","undefined는","undefined를","undefined와","union","unusable:","var","void","void는","void와","warn","warnuser():","x","x:","x[3]","x[6]","year","{","{red","{red,","|","}","}.","가능한","가능할","가드에","가장","가정하겠습니다.","가정합니다.","가지","가지고","가집니다.void와","가집니다.하나는","각각의","각기","간단한","감싸기","감싸져","값","값만","값에서","값은","값을","값의","값이","값입니다.","값입니다.이","강력한","같습니다","같습니다.","같은","같을","같이","개발자가","개수의","객체","객체도","객체에는","걸쳐","검사나","검사를","검색됩니다.","것과","것도","것으로","것은","것을","것이","것입니다.다른","것입니다.예를","결코","경우","경우에","경우에는,","경우에도","고급","고정된","과","과정에서","관한","구문은","구문입니다.나중에","구문입니다:","구조,","구체적일","권장하지만","그","그것들은","그러나","그렇지는","그리고","그에","기능은","기능이","기대하는","기본","기본적으로","기본적인","기존","꺼져","나타내기","나타낼","나타냅니다.예를","내가","내용이","논의하겠지만","놓일","다루게","다른","다음","다음과","다음에","단순한","단언","단언만","단위로","대신","대한","더","더욱","던지는","데이터","데이터를","도입된","동일합니다.다른","동적","될","됩니다.","두","들어","들어,","등과","따른","따옴표(\")","따옴표(')를","때","때는","때로는","때마다","때문에","또","또는","또한","라이브러리와","런타임에","마찬가지로","만","만드는","많은","말하는","말하자면","매기기를","매우(극단적으로)","매핑된","메모","메모:","메서드를","멤버","몇","모두","모든","목적상","못하는","못합니다.","무엇인지","문자로","문자를","문자열","문자열,","문자열은","문장과","문제는","문제들은","미치지","믿어,","및","반드시","반환","반환되는","반환하는","반환하지","받습니다.typescript는","발생하지","발생합니다.","방법","방법으로","방법으로는","방법이다.","방법입니다.type","배열","배열에는","배열을","배열이","백","백틱","번","번째","번호를","변경할","변수","변수를","변수에","변수의","변환(타입캐스팅)과","본","볼","부가적인","부동","부분은","부여하는","부울","부재도","부정확한","비롯될","비슷하지만","비슷한","비슷합니다:","사실일","사용됩니다.typescript는","사용됩니다:","사용으로","사용자","사용자가","사용하는","사용하도록","사용하려면","사용하면","사용하여","사용할","사용합니다.","사용합니다.javascript와","사용했음을","상응하는","상황에","새로운","샘플은","서버를","서브","선언","선언은","선언한","선택입니다.그러나","선택하지","선호도에","설명해야","설정하여","설정합니다:","소개","소수","수","수는","수도","수동으로","수행했다고","숫자","숫자,","숫자는","숫자형","스타일의","시작하는","시작할","시작합니다.멤버","실제로","실행","싶습니다.이를","쌍으로","써드","아닙니다","아닙니다.","안","안다\"라고","않고","않는","않습니다","않습니다)","않습니다.","않습니다.런타임에","않습니다.예를","않습니다:","않으며","않은","알","알고","알려진","알아야","알지","어떠한","어플리케이션을","언어에서처럼","언어와","언어의","없는","없습니다.","없습니다.일반적으로","없습니다:","없으며","엔티티의","여러","역할을","연결할","열거","열거형을","영향을","예는","예상할","예외를","예제를","오는","오류","오류,","오류:","오류를","올바른","외부의","외에도","요소","요소에","요소의","우리가","웹","위와","위의","위한","위해","유니온","유용하게","유용하고","유용하지","유용하지만","은","을","의해","이","이것은","이동할","이러한","이를","이름으로","이름을","이므로","이전","이후에","인덱스","인덱스을","일","일반적인","일부","일부를","일을","임의의","입니다","입니다.c#와","있기","있는","있다\";","있다고","있다는","있도록","있습니다","있습니다!","있습니다.","있습니다.string","있습니다.그러나","있습니다.다시","있습니다.어떤","있습니다.예를","있습니다.이","있습니다.이러한","있습니다.이렇게","있습니다.일반적으로","있습니다:","있어서는","있어야","있으며","있으므로","있을","있지","있지만","자료는","자세히","자신의","자체를","자체적인","작성","작성할","작업할","작은","장에서","재구성하지는","전달하고자","전혀","절대","절대로","점","점진적으로","접근하는","접근할","정반대이지만","제네릭","제외하고).ani","조금","조차도","존재하는","존재하지","존재할","존재합니다.","좁혀지더라도","좋습니다.","좋아요","좋아요,","주로","주제입니다.","줄에","중","중지(opt","지금까지","지원하기","지원하며","지원합니다.","지정합니다.","집합","집합에","참조하기","찾을","첫번째,","체크하지","초기화","추가","추가할","추론되는","친숙한","컨텐츠에서","컴파일","컴파일러는","컴파일러에게","컴파일러에서만","쿼트","큰","키워드","키워드는","키워드를","타임","타입","타입)을","타입도","타입보다","타입에","타입에만","타입으로","타입은","타입을","타입의","타입이","타입이거나","타입이며","타입입니다.즉","텍스트","텍스트의","템플릿","통과하도록","튜플","특별한","파티","페이지와","편리한","포함된","포함할","포함합니다.","표시합니다.","표준","표현식","표현식은","표현식을","표현식의","표현식이거나","표현식입니다.변수는","표현할","프로그램을","프로퍼티는","플래그를","피할","필요는","필요한","하고","하나는","하나로","하나를","하나의","하는","하면","한","할","할당","할당될","할당할","함께","함수","함수에는","함수의","합니다.","합니다.배열의","합니다.예를","항상","해결할","해당","핸드북의","허용됩니다.","현재","형","형식입니다.","형의","형태를","호출하는","호출할","혼재되어","화살표","확실하지","확실한","획득하지","흔한"],"pages/Variable Declarations.html":["\"\"","\"\",","\"$$\",","\"a","\"aurora\",","\"bar\"","\"baz\",","\"cat\";","\"danielle\",","\"foo\",","\"hello!\";","\"hello,","\"kitty\";","\"noisy\"","\"oh","\"rich\"","\"rich\",","\"rich\"를","\"rory\";","\"seattle\";","\"spicy\",","\"yes\"","\"결함\"을","\"존재\"합니다.이것은","\"좋아요\"","\"환경\"을","'0'","'10'","'100'","'11'","'2'","'a'가","'a'는","'a'를","'b'는","'const'를","'e'는","'foo'가","'undefined'","'x'를","'x'의","(array","(block","(condition)","(const","(default","(destructuring)","(e)","(function","(input)","(introduction)","(let","(object","(properti","(re","(scope","(shouldinitialize)","(spread)","(true)","(var","(variabl","({","(최소","+",",","...","...c","...default","...defaults,","...first,","...passthrough","...rest]","...second,","//","0","0);","0;","0입니다.","1","1,","10","1001","100;","101","10;","10을","10입니다.","12,","12;","1;","2","2,","20;","2;","2]);","2];","3","3,","3;","4","4,","4];","5","5];","5]값을","6","7","8","9","9;",":",";","=","[","[,","[0,","[1,","[3,","[first,","[first]","[number,","[second,","]","a++;","a,","a:","a:\"\"","a;","ambiance:","a{를","a를","a에","a와","a의","b","b:","b;","b?:","boolean)","bothplu","bothplus에","b가","b는","b를","b의","c","c();","c):","c:","captur","catch","citi","city;","city를","class","clone","clone.m();","clone.p;","console.log(\"oh","console.log(e);","console.log(first);","console.log(rest);","console.log(second);","const","const는","const를","const변수의","c를","dead","declar","declarations)","default","defaults의","destructuring)","develop","ecmascript2015","enumer","es2015를","f()","f();","f([1,","f([first,","f(condition,","f(false);","f(false,","f(input:","f(shouldinitialize:","f(true);","f(true,","f(x)","f({","f({});","first","first];","first와","foo()","foo();","food","food:","for루프에","fourth]","function","function()","f의","f함수","f함수가","f함수에서","g","g()","g();","getciti","getcity();","getcity;","g함수가","g함수는","handbook","handbook에서","hello","if문","iife로","iife를","input","input;","input[0];","input[1];","interfac","i가","i는","i를","i와","javascript","javascript로","javascript를","javascript에서","javascript의","javascript이므로","keepwholeobject","keepwholeobject(wholeobject:","kitti","kitty.nam","kitty.numl","let과","let은","let을","let의","let이","loop","m()","messag","message;","mozilla","name:","network의","new","newname1","newname1\"로","newname1,","newname1를","newname2","no!\";","number","number[][])","number])","numlives:","numlivesforcat","numlivesforcat,","o","o.a;","o.a와","o.b;","o.b에서","o;","p","passthrough.b","passthrough.c.length;","price:","principl","privileg","properties)","quirks)","readonly로","renaming)","return","rules)","scope","scoping)","scoping이라고","search","search의","second","second,","second]","second]:","second라는","second의","settimeout","settimeout은","shadow","shadowing)","shadowing은","shadows하기때문에","spread에는","string,","sum","summatrix","summatrix(matrix:","tempor","thecitythatalwayssleeps()","throw","total","tri","type","typescript","typescripts는","typescript가","typescript를","typescript에","typescript에서","typescript의","values)","var","var보다","var에","var와","void","vs.","well.\");","wholeobject;","wholeobject의","world!\";","x","x)","x;","x는","x를","x의","zone","{","}","})","}):","});","}:","};","}이며","}입니다.객체의","가깝게","가능","가능하게","가능합니다.","가장","가정할","가정해","가져오는","가지","가지고","가진","가집니다.","각","간단한","간략하게","간섭하고","값에","값은","값을","값이","갖습니다.","같습니다.","같습니다:","같은","같이","같지만","개념과","개발자","개발자들은","개요를","개의","객체","객체로","객체를","객체에","객체의","객체입니다.이것은","건너뛸","검입니다.","것과","것으로","것은","것을","것이","것이고","것이었습니다.그것은","것인지를","것입니다.","것입니다.javascript에서","것입니다.그러나","것입니다.선언전에","것입니다.이것을","것입니다.이러한","것입니다.이제","결과가","결과는","결과를","결론을","경우","경우의","계산을","고려해야","고맙게도","고통이었지만","관계없이","관련","관심이","관한","괄호로","교환","구문에","구문을","구조","구체적인","권한","권한을","규칙","규칙에","규칙은","규칙을","규칙이","그","그것들이","그것은","그들은","그러나","그런","그렇게","그렇습니다.","그리고","근본적인","기능","기능은","기다리고","기대합니다.","기본","기본값","기본값으로","기본값은","기본값을","기사를","기억을","기억하세요.","기억하세요?settimeout에","기억해야","기존의","깊은","까다로울","끝없는","끝에","나머지","나은","나중에","나타내는","내려야","내부","내부의","내에","내에서","내용","내용은","내용을","내의","네이밍을","네임","네트워크","놀라운","놀랐을","누출되는","는","다룰","다룹니다.","다른","다름","다릅니다.","다소","다시","다음","다음과","다행스럽게도","다행히","단순한","단점","단점을","단지","달리","당신은","당연합니다.대부분의","대답도","대부분","대부분의","대한","대해","더","던질","덮어","덮어쓰게","덮어씁니다.따라서","데이터","도입","도입하기보다는","독자는","동시에","동일하지만","동일한","동작에","동작을","된","될","됩니다.","됩니다.숙련된","두","두개의","두는","두번째,","들어","들어:","따라서","때","때까지","때마다","때문에","또","또는","또한","뜻은","뜻인지","런타임","런타임은","렉시컬","루프가","루프는","루프를","루프의","를","리뷰에서","만","만드는","만들","만듭니다.","만듭니다.이것이","만약","많은","말해줍니다.","매개","매개변수가","매개변수를","매우","먼저","멈추는","메서드를","멤버를","명확하게","명확한","몇","몇가지","모두","모듈,","모든","목록의","목표로","무슨","무시할","묶어야한다는","문안에","문을","문장을","문장이","문제가","문제를","문제점은","묻는","물론","밀리","및","바깥에서","바꾸기","바꿀","바람직한지를","바인딩","반대입니다.배열을","반복마다","반복문","반복문의","반복할","반환","발생해야합니다.","방금","방법은","방법이","방법이며","방법입니다.","방식으로","방지하기","방향은","배열","배열로","배열의","버그는","버그를","버그의","버전의","번","베이스에서","변경","변경할","변수","변수가","변수는","변수로","변수를","변수에","변수에도","변수에서도","변수와","변수의","변하지","보겠습니다.","보고하지","보세요:","보여","보통","복사본을","복잡합니다.배열은","볼","봅시다.settimeout은","부릅니다.매개변수","부여합니다.전개는","불구하고","불법이라는","불법입니다;","불변","블럭","블록","블록에","블록의","블록이","비구조화","비구조화는","비구조화된","비구조화를","비구조화시","비구조화의","비구조화입니다.전체","비구조화처럼","비구조화하는","비슷한","비해","뿐입니다.","사람들은","사람들을","사실입니다.","사용될","사용자가","사용하는","사용하는것은","사용하면","사용하세요.앞의","사용하여","사용하였습니다.","사용할","사용합니다.","사용합니다.스코프가","사용해야","사용해야한다는","사용했다면","살펴","살펴보았습니다.이것에","상대적으로","상위","상의하십시오.","상태는","상태를","새로운","새롭게","생각해","생긴","생성한","생성할","생성합니다.","생성합니다.해당","선언","선언과","선언되기","선언되어","선언되어야합니다.","선언된","선언될","선언됩니다.","선언들에","선언없이","선언에","선언에서도","선언으로","선언은","선언을","선언의","선언이","선언입니다.이전에","선언하기전에","선언하는","선언하였습니다.","선언한","선언할","선택사항으로","선택적인","설명","설명할","섹션에서는","섹션은","소개","속성(own,","수","수도","수정하면","수정할","쉽게","스스로","스코프","스코프가","스코프내에서","스코프는","스코프를","스코프에서","스코프의","스코프입니다.","스페이스","시간이","시나리오가","시작으로","시작했습니다.","시점에","실수가","실수로","실수를","실제로","실행","실행되는","실행될","실행됩니다.for","실행시키는","실행을","실행하는","실행하려고","실행하지만","실행해","심플하게","써놓지","쓰게","쓸","아니라","아니라는","아닌","아닙니다.","아닙니다.'","아닙니다.블록","아닙니다.형식을","아무렇게나","악화시키는","안됩니다.","않고는","않는","않다고","않더라도","않습니다.","않습니다.이","않은","알","알겠지만","알고","알다시피","알아냈습니다.그","앞에","앞에서","약간의","양날의","얕은","어떤","어떻게","어쩌면","언급한","언급했듯이","언급했습니다.","언어에서","언어의","얻었습니다.실제로","얻었을","없는","없다는","없습니다.","없습니다.즉","없었습니다.","없으므로","에","에서는","여기","여기서","여기에","여러","여부를","여전히","연결됩니다.","연산자","열거","예를","예방할","예상됩니다.","예상을","예상한대로","예에서","예제를","예제에서","예제입니다.","예측","오류","오류!","오류,","오류:","오류가","오류로","오류를","오른쪽으로","완료","완료된","완전히","왜","외부에서","외부의","왼쪽에서","요소는","요소들","우리가","우리는","우리에게","우발적인","우선","원인이","원칙)","원한","위의","위한","위해","유발하는","유발할","유사하지만","유사한","유지하세요.","유형","유형의","유효합니다.이것은","으로","은","을","의","의미론을","의미에","의미합니다.","의해","이","이것은","이것이","이곳에서","이는","이라고","이라는","이러한","이런","이를","이름","이름에서","이름으로","이름을","이미","이번","이상하게","이상한","이유는","이유입니다.let은","이전","이전에","이전의","이제는","이해하기","익숙하지","인덱스를","인수를","인스턴스를","일단","일반","일반적으로","일반적이며","일반적인","일반적입니다.매개","일부로","일정한","읽거나","읽을","잃어버린다는","있기","있는","있는지","있다.","있다고","있다는","있다면","있던","있듯이","있습니다","있습니다.","있습니다.)","있습니다.a의","있습니다.const는","있습니다.var","있습니다.그들이","있습니다.다음","있습니다.변수","있습니다.최선을","있습니다.하지만","있어야","있었던","있을","있지만","자동으로","자세한","자세히","자연스럽게","자체에","작고","작동하는지","작동합니다.","작동합니다.간단한","작성됩니다.","작성하기","작성해야","작성했다고","작업하는","잘","잘못된","잠깐","재","재선언과","재할당","적용하면","전개","전개는","전개로","전개를","전개보다","전개에","전개하는","전개한","전개할","전달하는","전에","전에는","전역","전체","전통적으로","점에서","점은","접근","접근이","접근하여","접근할","접했을","정교한","정보는","정의되지","정확히","제공하려면","제공합니다.","제외하고는","제외한","제한되어있고","제한되어있습니다.","조심히","조치를","존재하지","존재할","종류의","종종","좋아요","좋아요,","좋은","좌절의","주기","주듯이","주목하십시오.javascript는","주석으로","주어진","주의해야","준비됐나요?","중요하지","중요한","중지","중지했을","중첩된","즉시","지금은","지나면","지역변수","지역변수로","지원합니다.여기서","지정","지정되었다는","지정하는","지정한다는","지정할","직감을","직감적이고","직접","진행하지만","질문들과","집합이기","차이점은","참조","참조하기","참조하는","참조하며","참조하세요.이","참조하십시오.","참조합니다.","찾을","챕터에서","처음","첫번째,","초","초기화가","최선의","추론의","추론할","출력","출력됩니다.","출력을","출력합니다!","취하지","친숙하지만","캡쳐","캡쳐된","캡쳐를","캡쳐링에","캡쳐링의","캡쳐하기","캡쳐하는","캡쳐한","캡쳐할","캡쳐합니다","캡쳐했으므로","컴파일러는","코드","코드는","코드를","코드의","콜론은","크게","키워드를","타입을","통해","특히","팀원들과","파싱합니다.","판단을","패턴은","패턴을","편리합니다.","포함된","포함됩니다.기본적으로","표현식은","표현식을","표현식인","프로퍼티","프로퍼티가","프로퍼티는","프로퍼티를","프로퍼티뿐만","프로퍼티에","프로퍼티의","피할","피해야","필요가","필요없는","필요하지","필요합니다.","하고","하나","하는","하여","한","한가지","한계가","한다면","한번","할","할당","할당입니다.","할당할","할수","함께","함수","함수,","함수가","함수는","함수로","함수를","함수에","함수을","함수의","합니다.","합니다.(실행이","합니다.c에서","합니다.루프","합니다.이를","항목에","항목이","항상","해결","해당","해당되는","해보세요","해체","해체할","했기","했음에도","향후","허용되며","허용하지","허용합니다.","현대적인","현재","형식을","형식이","형태를","호출되는","호출되더라도","호출될","호출로","혼동되어서는","혼란스러워지기","혼란스럽겠지만","혼란스럽습니다.이름","혼자가","확실히","확장입니다.","환경","환경내에서","환경을","활용할","횟수가","후에","후에는","후에도","후행","훨씬","흐름을","흭득하였습니다.","힘든"],"pages/Interfaces.html":["\"100\"","\"black\"","\"blue\";","\"bob\"];","\"fred\"];","\"mallory\";","\"red\",","\"size","\"white\",","\"구조적","\"대상","\"덕","\"사전(dictionary)\"","\"옵션","\"인덱스\"를","\"회피하는\"","'clor'프로퍼티가","'colour'는","'image'","'name'의","'squareconfig'","'state'","(class","(config.color)","(config.width)","(excess","(extend","(function","(hour:","(hybrid","(implement","(interfac","(introduction)","(number)로","(option","(our","(readonli","(source:","(start:","(string)으로","):","*","...","//","0.5","10","10,","100","100,","100;","10;","12,","123;","12;","17);","1;","2,","20","3,","32);","32)에","4];","5.0;","5;","7,",":","=",">","?로","[\"alice\",","[\"bob\",","[1,","[index:","[propname:","[x:","a:","a;","a[10]","agemap[\"daniel\"]처럼","analog","analogclock","analogclock이","anim","animal;","animal을","any;","area:","array","array와","assertion)을","bags)\"과","bags)\"을","bags)과","beep\");","between","boolean","boolean;","breed:","button","c","c#","c(10);","c.interv","c.reset();","checks)","class","classes)","clock","clockconstructor","clockconstructor,","clockconstructor와","clockinterfac","clockinterface;","clockinterface라는","color","color:","color?:","color가","colour","colour:","config.clor;","config.color;","config.width","config.width;","console.log(\"beep","console.log(\"tick","console.log(labelledobj.label);","const","constructor(h:","const를","control","control과","control을","control의","counter","counter.interv","counter.reset","counter;","createclock","createclock(","createclock(analogclock,","createclock(digitalclock,","createclock의","createsquare(config:","createsquare(squareoptions);","createsquare({","createsquare를","createsquare에서","createsquare의","ctor(hour,","ctor:","currenttime:","d;","date)","date);","date;","digit","digitalclock","dog","dog;","extend","false)함수","first","function","function()","function(source:","function(src,","function(src:","function(start:","getcounter():","getcounter();","hour:","imag","implement","index","instanc","interfac","interface)","interfaces)","interval:","java","javascript","label","label:","labelledvalu","labelledvalue)","labelledvalue은","label이라는","length:","length는","locat","m:","minute);","minute:","myarray","myarray:","myarray[0];","myarray[2]","myarray[2]를","myobj","mysearch","mysearch:","mysquar","mystr:","name:","name의","new","newsquar","newsquare.area","newsquare.color","newsquare;","notokay","number","number)","number):","number);","number,","number;","number[]","number[];","number]:","numberdictionari","number로","number입니다.","numeric과","obj.property가","obj[\"property\"]으로도","object\"","opacity:","p1.x","p1:","penstrok","penwidth:","point","point를","printlabel(labelledobj:","printlabel(myobj);","printlabel에","privat","properti","properties)","protect","public","readonli","readonlyarray","readonlyarray를","readonlyarray타입이","readonlystringarray","readonly를","readonly을","reset():","result","return","ro","ro.length","ro.push(5);","ro:","ro;","ro[0]","searchfunc","searchfunc;","select","select()","select():","selectablecontrol","selectablecontrol에는","selectablecontrol은","selectablecontrol을","selectablecontrol의","settime(d:","settime과","shape","shape,","side","sidelength:","signatur","signature)","signature)을","signatures)에","signatures)을","signatures)이","size:","source.search(substring);","squar","square.color","square.penwidth","square.sidelength","squareconfig","squareconfig):","squareconfig);","squareconfig가","squareconfig은","squareconfig의","squareopt","squareoptions은","src.search(sub);","state","state:","static","string","string)","string):","string,","string;","string]:","stringarray","stringarray;","stringarray이","string으로","string을","sub)","sub:","substring:","subtyping)\"라고도","textbox","this.currenttim","tick()","tick();","tock\");","true와","types)","typescript","typing)\"","typing)에","void;","vs","width","width:","width?:","width가","x:","x와","y:","y는","{","{}","{};","}","})","});","};","}으로만","}을","가","가능","가능하다는","가능한","가능해야","가장","가져야","가지","가지고","가지기","가지는","가지를","가진","가질","가집니다.실제로","각","간단한","간단합니다.가장","값에","값을","값이","강력한","강요합니다.문자열","강제가","같습니다.","같습니다.인터페이스는","같은","같이","개의","객체","객체가","객체는","객체로","객체를","객체에","거치지","거칩니다.객체","검사","검사(excess","검사되기","검사되며","검사를","검사에","검사을","검사하는","검사할","검사합니다.typescript","검사합니다.타입을","것","것과","것들은","것은","것을","것이","것입니다","것입니다.","것입니다.변수는","것입니다.예를","것입니다.이것은","것입니다:","것조차도","결합하는","결합하여","경고했을","경우","경우도","경우에","경우에는","계약을","계층이","관대하지","관련이","괜찮은","구성","구현","구현된","구현을","구현하는","구현한다고","구현할","그것이","그러나","그렇게","그렇지","금지되어","기법을","기본","기억할","끝에","나열된","나타납니다(여기서는","나타냅니다.","나타냅니다.객체","내에서","너무","넣어","는","다","다룰","다른","다만","다시","다양한","다음과","다음은","단언(assertion)을","단언(type","단일","대로","대부분의","대수롭지","대신","대한","대해","대해서","더","데","동시에","동일하므로","동일한","동적이고","되지","될","두","둘","들어","들어:","따라","때","때때로","때만","때문에","때문입니다).그러나","때문입니다.다음","때문입니다.생성자는","때문입니다.이것은","때문입니다.즉","또","또는","또한","를","리터럴에","리터럴은","리터럴을","리터럴의","마음이겠지만","마지막","마지막으로","마찬가지로","마치","만드는","만들","만들고","만듭니다.클래스를","많은","많이","말아야","말하는","말할","맞추는","매개","매개변수가","메서드가","메서드를","메시지가","멤버가","멤버들을","멤버들이","멤버를","멤버에","멤버이기","멤버조차도","명시적으로","명시적인","명심하세요:","몇","모두","모든","목록과","목록의","무덤을","문자열","문자열(string)","문자열과","문자열을","문제","문제가","묻는","물건에","및","바꿀","반면","반환","반환되는","반환된","반환하는","반환한다는","받아","발생하는","발생할","발생합니다.","방법","방법과","방법으로","방법은","방법을","방법이지만","방법입니다.","방식으로","방식을","방지할","배열로","배열을","배웠고","배웠습니다.","백(option","버그가","버그입니다.즉","번째","변경하지","변수","변수는","변수를","변수에","변수에는","변수에서","변수의","변형","변환하기","보겠습니다.","보여줍니다.","보통의","복사할","복잡한","볼","봅시다:","분리하는","불구하고","불법임을","붙여","비교하며","뿐입니다.","사용","사용되는","사용됩니다.","사용을","사용하는","사용하면","사용하여","사용한","사용할","사용할지","사용할지를","사용합니다.","사용해야","사항을","상속","상속받는","상속받으며","상속하지는","상속하지만","상속합니다.즉","상태를","상호","생성","생성자","생성자를","생성하고","생성하는","생성하려고","생성하면","생성할","서로","서로를","서브","선언","선언과","선언된","선언에서","선언하기","선언한","선택적","설명된","설명하기","설명하는","설명할","설정할","소개","소위","속성도","속성이","수","수는","수도","수정할","수정해야","순서대로","숫자(numeric)","숫자나","숫자의","쉬운","스태틱","스태틱과","시그니처(call","시그니처(constructor","시그니처(index","시그니처(string","시그니처에는","시그니처은","시그니처이","시도를","시작된","시작하는","시점에","실제","실제로","실패합니다.","싶은","써드","아니면","아닌","아닙니다.","아래의","아예","않고","않기","않는다는","않도록","않습니다.","않습니다.이는","않습니다:","않으려는","않으며","않은","않을","알","알려진","암시적으로","앞에","어떻게","언급했듯이","언어로","언어처럼","얻을","없는","없습니다.","없습니다.어떤","없습니다.예를","없었습니다.여기서는","없으며","에","에는","에서","에서는","에서도","여기서","여러","역할을","예로는","예를","예상하는","예에서","예에서는","예입니다:","예제를","예제에서","예제에서는","예제의","오류","오류!","오류,","오류:","오류가","오류는","오류를","오버라이드","올바른","옵션","와","완전히","왜냐하면","외부에서","외에는","외에도","요구","요구하지","우리는","원리","위에","위에서","위와","위의","위치의","위한","위해","유사하게","유연하게","유연한","유용한지도","유용합니다.서브","유지하고","유지하는","유형화(structur","으로","을","의","의해서도","이","이는","이러한","이런","이름","이름과","이름을","이름이","이름입니다.여전히","이번에도","이보다","이야기하겠지만","이에","이전","이전에","이후에","인덱서(indexer)를","인덱서에서","인덱서의","인덱스","인덱스에","인덱스의","인덱싱","인덱싱을","인덱싱하기","인덱싱하는","인덱싱하면","인수","인수는","인수로","인스턴스","인스턴스를","인스턴스의","인터페이스","인터페이스가","인터페이스는","인터페이스도","인터페이스로","인터페이스를","인터페이스에","인터페이스와","인터페이스의","인터페이스처럼","인해","일관성이","일단","일반적인","일부","일부를","일부만","일치하는지만","일치하도록","일치하지","일치할","읽기","입니다.","입력하면","있고","있는","있는지","있다고","있다는","있습니다!","있습니다.","있습니다.createsquare에","있습니다.javascript","있습니다.printlabel에","있습니다.state는","있습니다.그럼에도","있습니다.두","있습니다.또한","있습니다.실제로","있습니다.여기서는","있습니다.예를","있습니다.왜냐하면","있습니다.이","있습니다.이러한","있습니다.이렇게","있습니다.인덱싱","있습니다.프로퍼티를","있습니다:","있어야","있으며","있으므로","있을","있음을","있지만","자세히","자식들만이","자식만","자신의","작동","작동하는","작동하도록","작성되며","작성할","작업은","작업할","작업해야","작용할","잘못","장점은","재사용","전달되는","전달된","전달하는","전달할","전에","전용","전용(readonly)으로","전용이므로","전체","점을","접근할","정말","정의되면","정의를","정의하고","정의하는","정의할","정의합니다.","정의합니다.편의상","정적인","제거된","제공되는","제공될","제공하지","제공합니다.이것은","조건","조용히","조합으로","존재하거나","존재하지","좀","종류의","종종","좋습니다.","좋아요,","주어진","주장할","줄에서","중","중에서","중요한","중요합니다.","지원되는","지원할","지적하는","지정되므로","지정하는","지정하려는","지정하지","지정할","직접","차이점(differ","채워진","처리를","처음","첫","첫번째","체커가","체커는","체커에서","체커에서는","체킹을","초과","초점을","최소한","추가","추가하는","추론할","충족하는","충족하도록","취할","측면과","측면만","측면에서","측면의","측면이","측면이기","측에","컨텍스트","컴파일러가","컴파일러는","컴포넌트로","코드","코드가","코드를","코드에","코드의","크지만","클래스","클래스가","클래스는","클래스를","클래스에","클래스에서","클래스에서만","클래스와","클래스의","클래스처럼","타이핑(duck","타입","타입\"에","타입(contextu","타입(index","타입construct","타입과","타입만","타입에","타입에는","타입에서","타입은","타입을","타입의","타입이","타입이므로","타입이어야","타입인","타입임을","타입입니다(왜냐하면","통해","특별하게","특별한","특성으로","특정","특정한","파는","파라미터","파티","패턴을","패턴의","포함되는","포함되어","포함되지","포함된","포함한","표시됩니다.","표시됩니다:","표시합니다","표현식의","표현식이","풍부한","프로그램이","프로젝트","프로퍼티","프로퍼티가","프로퍼티는","프로퍼티들을","프로퍼티들의","프로퍼티로","프로퍼티를","프로퍼티에","프로퍼티에서","프로퍼티의","필수로","필요가","필요는","필요하다는","필요하지","필요한","필요할","필요합니다.","하고","하나는","하나로","하나씩","하는","하며","하면","하에","하위","하이브리드","하지","하지만","한","한다는","할","할당","할당되지","할당하거나","할당하는","할당하여","함수","함수로","함수를","함수에","함수에는","함수와","함수의","합니다.","합니다.button과","합니다.typescript","합니다.메서드와","합니다.왜냐하면","합니다.이","합니다.프로퍼티","항목으로","해당","핵심","허용됩니다.","형성하기","형성하려면","형성할","형태","형태를","형태을","형태일","호출","호출을","호환","호환되고","확실한","확인하는","확인합니다.","확인합니다.printlabel","확장","확장하는","확장하면","확장하여","확장할","후"],"pages/Classes.html":["\"","\"bob","\"greeter","\"greeter라는","\"hello,","\"hey","\"man","\"sales\");","\"secret","\"인스턴스","${distanceinmeters}m.`);","${this.department}.`;","${this.name}","&&","'animal'과","'employee'는","'name'은","'person'의","()","(abstract","(accessors)","(advanc","(classes)","(constructor","(employee.fullname)","(function","(inheritance)","(introduction)","(paramet","(passcod","(point.i","(point.x","(public","(public,","(readonli","(static","(thename:","(this.greeting)","(understand","(use","*","+",".d.t","/","//","0)","0,","0};","1,","10,","10am.\");","10}));","1x","2,","2015년을","3","34m.","3};","3개의","45)","5)","5m.","5x","8","8;",":","=","==","_fullname:","`hello,","abstract","abstract으로","account","accountingdepart","accountingdepartment();","anim","animal(\"cat\").name;","animal(\"goat\");","animal과","animal로","animal로부터","animal에","animal에서","animal의","auditing\");","bark()","bark()와","c#","c#의","calculatedistancefromorigin(point:","class","classes)","console.log(\"depart","console.log(\"galloping...\");","console.log(\"gener","console.log(\"roam","console.log(\"slithering...\");","console.log(\"th","console.log(\"오류","console.log('woof!","console.log(`${this.name}","console.log(`anim","console.log(employee.fullname);","console.log(greeter.greet());","console.log(greeter1.greet());","console.log(greeter2.greet());","console.log(grid1.calculatedistancefromorigin({x:","console.log(grid2.calculatedistancefromorigin({x:","console.log(howard.getelevatorpitch());","console.log(howard.name);","const","constructor","constructor()","constructor(message:","constructor(name:","constructor(publ","constructor(readonli","constructor(thename:","dad","dad.nam","default)","depart","department();","department.generatereports();","department.printmeeting();","department.printname();","department:","department;","dog","dog();","dog.bark();","dog.move(10);","dog는","dog의","each","earth...\");","ecmascript","ecmascript3","ecmascript5","employe","employee(\"bob\");","employee(\"howard\",","employee();","employee.fullnam","employee;","employee는","employee라는","employee를","employee에게","employee의","extend","fullname():","fullname(newname:","fullname:","fullname에","fullname을","function","functions)","galloping...","generatereports():","getelevatorpitch()","getters/setters를","getter와","get과","get을","greet","greet()","greeter","greeter(\"world\");","greeter();","greeter(message)","greeter.prototype.greet","greeter.standardgreeting;","greeter1","greeter1:","greeter1은","greeter2:","greeter:","greeter;","greetermaker();","greetermaker.standardgreet","greetermaker:","greetermaker라는","greeter는","greeter라고","greeter를","greeter을","greeter의","greeting:","grid","grid(1.0);","grid(5.0);","grid.origin.x);","grid.origin.y);","grid1","grid2","grid를","grid의","hors","horse(\"tommi","horse과","horse는","horse의","howard","interfac","interface)","javascript","javascript는","javascript로","javascript를","java를","john","legs\");","makesound():","math.sqrt(xdist","meet","message;","modifier)","modifiers)","monday","move","move()","move():","move(distanceinmet","move(distanceinmeters:","move를","name","name:","name;","name과","name은","name을","name이라는","new","newname;","new를","number","number)","number;","number;})","numberoflegs:","octopu","octopus(\"man","origin","origin에","palomino","palomino\");","passcod","passcode\")","passcode\";","passcode가","passcode를","person","person(\"john\");","person으로부터","person을","person의","piec","point","point3d","point3d:","printmeeting():","printname():","privat","private)","private,","private멤버가","private으로","private을","private의","private이다;","properties)","protect","protected)","protected로","protected멤버가","protected멤버에도","protected입니다.","public","public,","public를","public와","public으로","public을","public입니다.","python","python\");","readonli","readonly도","readonly로","readonly입니다.","reports...\");","return","rhino","rhino();","rhino;","rhino가","rhino는","sam","sam.move();","sammi","scale","scale:","set","setter가","set으로","set을","slithering...","smith\";","snake","snake(\"sammi","snake와","snake을","standardgreet","static","string","string)","string,","string;","strong","suit\";","super(\"account","super(\"rhino\");","super()를","super(name);","super.move(distanceinmeters);","symbol","techniques)","thename;","thename으로","thename을","there!\";","there\";","this.","this._fullnam","this._fullname;","this.depart","this.greet","this.greeting;","this.nam","this.name);","this.scale;","this를","this에","tom.move(34);","tom.move(34)를","tom:","tommi","tom은","typeof","typescript가","typescript는","typescript에서","typescript에서는","void","void;","woof!');","work","x:","xdist","y:","ydist","ydist)","z:","{","{x:","}","})();","};","가능하다면","가능한","가장","가지","가지고","가지를","가지므로","가진","각","간단한","값에","값을","값이기","같아","같이","개발자가","개발자는","개발자들에게는","개발자에게는","개의","객체","객체가","객체를","객체에서","객체의","거의","것과","것으로","것은","것을","것이","것입니다.","것입니다.new를","것입니다.게다가","것입니다.예를","것처럼","경고","경우","경우는","계속해서","고급","고유한","곳에서","공유하기","과정이","관계없이","교체합니다.앞의","구문을","구문이","구조적인","구체적으로","구축","구축되는","구현","구현을","구현해야","권한을","권한이","규칙입니다.","그","그것들이","그러나","그런","그럼에도","그렇지","그리고","그에","기능을","기능이","기다리지","기반","기반의","기법","기본","기본적으로","기본적인","기분","기술을","기존","나타납니다.또한","나타내는","내에서","내의","내키는","느낄","다","다룹니다.이번에도","다르게","다른","다소","다운그레이드는","다음","다음과","달리","대로","대한","대해","대해서만","더","데","동시에","동일한","동작합니다.단","된다는","될","두","둘","둘째,","들어","등장합니다.","때","때문에","때문입니다.","또","또는","또한","뜻합니다.","라고","라고도","를","마지막","마찬가지입니다.","만드는","만들","만들고","만들기","만듭니다.","만듭니다.이","만듭니다.이것은","말합니다.","매개","매개변수","매개변수를","매우","먼저","메서드","메서드가","메서드는","메서드를","메서드와","메시지를","메이저","멤버","멤버가","멤버는","멤버도","멤버들에","멤버를","멤버에","멤버의","명시적으로","명시해야합니다.","몇","모두로","모든","무단","문제를","미리","및","바꿀","바로","받게","받을","발생하는지","발생합니다.employee도","방법도","방법으로","방법은","방법을","방법입니다.매개변수","방식에","방식을","버전에서는","버전을","번째","변경할","변수","변수는","변수를","변환해봅시다.","보겠습니다:","보여","보여야","보여줍니다:","보이는","복잡한","본","본문을","볼","봅시다.","부르는","부여하는","불구하고","붙여","붙입니다.","브라우저와","비교할","비슷하게","사람들이","사실을","사용됩니다.","사용자가","사용하고","사용하기","사용하는","사용하도록","사용하려면","사용하면","사용하여","사용하지","사용하지만","사용한","사용할","사용합니다.각","사용합니다.둘","사용합니다.여기서","사용합니다.이것는","사용합니다.이것은","사용합니다.즉","사용해","삭제했는지","살펴보겠습니다.","살펴보겠습니다:","상속","상속받습니다.여기서","상속을","상속하고","상응하는","새","새로운","생각하는","생성된","생성됩니다.","생성자","생성자는","생성자를","생성자에서","생성자와","생성하고","생성하는","생성할","생성합니다:","서로를","선언","선언과","선언되고","선언되었지만","선언된","선언에서","선언으로부터","선언은","선언이","선언하면","선언한","선언합니다.","선언합니다.매개","선언했습니다.그","선택적으로","설명합니다.","설정하는","설정해야","설정했습니다.","세부","세부적으로","섹션의","소개","속성과","수","수는","수도","수정하고","수정할","수정합니다:","수정해","슈퍼","스태틱","스태틱을","시스템입니다.두","시작으로","시작합시다.","실제로","실행하면","실행하여","실행할","아니라","아닌","아닙니다.","않고","않고도","않는다는","않습니다.","않아도","않으므로","않은","않을","알","알려진","알아보기","알아야","알았을","앞서","앞에","약간","어디서","어떠한","어떻게","어색함을","언급하지","언급한","언어를","언어의","얻습니다.생성자","업데이트","업데이트!\");","없는","없다는","없습니다.","없습니다.인터페이스와","없지만","여기서","여기서는","여기에서","여러","여전히","예","예를","예제가","예제는","예제를","예제부터","예제에서","예제에서는","예제와의","예제의","오류","오류!","오류:","오류가","오버라이드","오버라이드하고","오버라이딩","왔는지에","왜냐하면","외부에서","외부에서는","원활하게","위의","위치에서","위한","위해","유래된","유사하게","유사한","유용합니다.","유지하거나","응용","이","이것은","이러한","이를","이름을","이상을","이야기했습니다.인스턴스는","이전","이전과","이전에","이제","이해하기","익숙하게","익숙하다면","익숙하지","인스턴스","인스턴스가","인스턴스는","인스턴스들을","인스턴스를","인스턴스에서","인스턴스의","인스턴스화될","인스턴스화하고","인스턴스화할","인터셉트하는","인터페이스","인터페이스로","인터페이스를","일반적인","일으킬","일이","일치하지","읽기","임의로","입증하기","있기","있는","있는지","있다고","있다는","있다면","있도록","있습니다","있습니다.","있습니다.abstract","있습니다.ecmascript6로도","있습니다.typescript에서는","있습니다.다음은","있습니다.이러한","있습니다.이전","있습니다.즉","있습니다.클래스","있습니다:","있어야","있었습니다.","있었습니다:","있지만","자동적으로","자유롭게","자체가","자체를","자체에","자체의","작동하는","작동하는지를","작동하도록","작동합니다.greeter","작성하기","작성할","잘","장소로","재사용","적용됩니다.","적용할","적이","전에","전용","전용으로","전통적인","점은","접근","접근을","접근자","접근자가","접근자는","접근자를","접근자에","접근하기","접근하는","접근할","접근합니다.인스턴스의","접두어로","정보를","정의하는","정의하여","정의한","정의합니다.그러나","정적","정확하게","제공합니다\".또는","제공합니다\".이","제어할","존재하지","좀","종종","좋아요:","주기","주며","주의사항:","줄에서는","줍니다.","중","중요한","지금까지는","지원되지","지원합니다.이것을","지정자","지정자(access","지정자는","지정자를","지정자와","지향","직접","직접적으로","직접적인","진행되고","차이를","참조를","참조할","처리합니다.","첫","첫째,","초기화됩니다.마찬가지로","초기화할","초기화합니다.","초기화해야합니다.","추가적으로","추가하는","추가합니다.","추론됩니다.이것은","추상","추상적이지","출력하도록","측면과","측면이","컴파일","컴파일러를","컴포넌트를","코드에서","클래스","클래스(subclasses)","클래스(superclasses)","클래스가","클래스는","클래스들의","클래스를","클래스뿐만","클래스에","클래스에는","클래스에서","클래스의","클래스인","클래스입니다.또한","클래스입니다.추상","클래스입니다.파생","키워드가","키워드는","키워드를","타입","타입과","타입들은","타입에","타입에는","타입으로","타입을","타입의","타입이","타입인","타입입니다.","통합했습니다.","통해","특성입니다.","특화된","파생","파생되기","파생된","파생될","파일을","판단되는","패턴","패턴을","편리하지만","포함됩니다.greetermaker에","포함됩니다.각각의","포함하는","포함하지","포함할","포함해야","표시되면","표시된","표시될","표시하도록","표시할","프로그래밍에서","프로그램을","프로토","프로퍼티","프로퍼티(paramet","프로퍼티는","프로퍼티들은","프로퍼티들을","프로퍼티를","프로퍼티에","프로퍼티와","플랫폼에서","하기","하나는","하나를","하나의","하는","하며","하위","한","할","할당","할당을","할당하려고","할당하여","할당합니다.","함께","함수","함수라고","함수를","함수에는","함수와","함수의","함수입니다.","함수클래스는","합니다.","합니다.새로운","합니다.이것은","합니다.추상","항상","형태를","형태의","호출되는","호출됩니다:","호출하고","호출하면","호출하여","호출합니다.","호출해야","호출해야한다는","호출해야합니다.","호환","호환되지","호환됩니다.그러나","호환성(compatible)이","확인하고","확인하기","확인할","확인합니다.이를","확장될","확장시키기","확장하여","확장할"],"pages/Functions.html":["\"","\");","\"adams\");","\"adams\",","\"bob","\"clubs\",","\"diamonds\",","\"diamonds\"],","\"diamonds\"];","\"hearts\",","\"lucas\",","\"mackinzie\");","\"number\")","\"object\")","\"samuel\",","\"smith\")","\"smith\"로","\"spades\",","\"sr.\");","\"this\"를","\"will","\"will\",","\"상황적","\"숨겨진","%","'this'를","'x'와","'y'에는","()","(...)","(basevalue:","(e:","(firstname:","(fname:","(function","(functions)","(infer","(introduction)","(lastname)","(option","(overloads)","(rest","(thi","(this:","(type","(typeof","(write","(x)","(x:","*","+","...","...rest:","...restofname:","/","//","10","100;","13","13);","13};","2","4","52);","6의",":","=","==","=>","?를","[\"hearts\",","[pickedsuit]의","[{","adams\"를","add(x,","add(x:","addclicklistener(onclick:","addclicklistener가","addclicklistener에","addtoz(x,","alert","alert(\"card:","annotated되어","annotate를","any가","api를","api의","arguments를","array(52),","arrow","buildname(\"bob\");","buildname(\"bob\",","buildname(\"joseph\",","buildname(firstnam","buildname(firstname:","buildname(undefined,","buildname;","buildnamefun:","callbacks)","capture라고","card","card:","card;","cardpick","cardpicker();","cardpicker()는","cards:","card를","card와","class","console.log('clicked!');","createcardpicker(this:","createcardpicker:","createcardpicker는","deck","deck)","deck):","deck.createcardpicker();","deck:","deck객체를","deck를","deck에","default","e.messag","e.message;","e:","ecmascript","employeenam","event)","f(this:","first","firstnam","firstname;","firstname에","function","function()","function(this:","function(x,","function(x:","function)","functions)","h","handler","handler();","handler,","handler의","increment:","info:","initi","interfac","invoc","javascript","javascript는","javascript에서","javascript에서와","javascript와","javascript의","katz의","last","lastnam","lastname:","lastname;","lastname?:","math.floor(math.random()","math.floor(pickedcard","math.floor(x","mode)에서","myadd","myadd:","myadd는","mydeck","mydeck[pickcard(mydeck)];","name","name을","name의","new","noimplicitthi","noimplicitthis는","number","number)","number):","number,","number;","number[];","onclickbad(this:","onclickbad는","onclickgood","onclickgood(this:","onclickgood는","onclick이","paramet","parameters)","parameters)라고","pickcard","pickcard(15);","pickcard(x):","pickcard(x:","pickedcard","pickedcard.card","pickedcard.suit);","pickedcard1","pickedcard1.card","pickedcard1.suit);","pickedcard2","pickedcard2.card","pickedcard2.suit);","pickedcard;","pickedsuit","restofname.join(\"","result1","result2","result3","result4","return","smith\"를","string","string)","string,","string;","string[])","string[];","suit","suit:","suits:","suits[pickedsuit],","this.info","this.info를","this.suit","this.suits[pickedsuit],","this가","this는","this를","this에","this와","this을","this의","type)","types)","typescript","typescript가","typescript는","typescript는createcardpicker가","typescript에","typescript에서","typescript에서는","typing)\"이라고","uielement","uielement.addclicklistener(h.onclickbad);","uielement.addclicklistener(h.onclickgood);","undefined);","undefined가","undefined를","undefined입니다.","understand","void)","void):","void,","void;","void가","void는","void로","void를","void이기","window로","window를","window보다는","x","x.length);","y","y)","y:","y;","yehuda","z","z;","{","{suit:","}","},","};","}[]):","}];","가독성을","가장","가정합니다.null","가정합니다.간단히","가져올","가져와야","가지","가지고","가짜","각","간단한","간주됩니다.","값은","값을","강력하고","같은","같이","개발자들도","개의","객체","객체는","객체를","객체마다","객체에서","검사를","것","것과","것에서","것으로","것은","것을","것이","것이다.이","것입니다).","것입니다.","것입니다.pickcard가","것입니다.또한","것입니다.반면에","것처럼","경고를","경우","경우에는","계속","계속합니다.일치하는","계층,","곳에서","곳이","공유됩니다.","공유한다는","공유합니다.lastname의","공통점을","공통점이","관계","구문","구문으로","구성하는","구성하지","구성합니다.캡처된","구체적인","구축하는","굵은","그","그것들은","그것이","그들이","그럼에도","그렇다면","그렇지","그룹으로","그리고","글에는","기능에","기능을","기능이지만","기대하는","기록하여","기명","기반으로","기법의","기본","기본값을","기본적인","기술한","끝에","나뉩니다:","나머지","나오는","나올","나중에","나타내는","남겨","남겨졌습니다.","내부","내부의","내용만","내용을","너무","넘겨주면","넘겨줄","넣어야합니다.","네임","노력을","높을","다","다룰","다른","다음","다음과","다음에","단점은","달리","달아야","대답은","대로","대부분","대신","대신에","대한","대해","더","덜","데","덱을","돕기","동일한","동작을","동적인","되면","된","될","됩니다:","두","두가지","두개의","두지","둘","뒤에","드는","드문","들어","듭니다.특히","따라","따라서","따라와야","딱","때","때는","때때로","때를","때문에","때문입니다.왜냐하면","때문입니다.이","때문입니다.이와","때의","또는","또한","라이브러리","라이브러리가","라이브러리에","런타임","리터럴","리턴문를","마지막","마지막에","마지막으로","마찬가지로","만들","만들고","만들어지고","만큼","많아지면","많은","말합니다.이","말해서","맞습니다","매개","매개변수","매개변수(default","매개변수가","매개변수가에","매개변수는","매개변수들의","매개변수들이","매개변수라고","매개변수로","매개변수를","매개변수에","매개변수와","매개변수의","매개변수입니다:","매개변수처럼","매우","먼저","메서드","메서드는","메커니즘이","명시적으로","명시해야","명확하게","명확하고","몇","몇가지","모두","모두를","모듈을","모듈이","모든","모를","모을수","목록과","목록에서","목록은","목록을","목록의","무엇을","무한적인","문제를","및","반드시","반영되지","반환","반환하거나","반환하기","반환하는","반환하지","반환합니다","반환합니다.","반환합니다.사용자가","받아들일","발견합니다.오류를","발생시키지","발생할","발생합니다.","발생합니다.createcardpicker에","방법과","방법을","방법입니다.typescript에서는","방식이","방지할","배열로","배열을","배우는","배워야","번만","번에","번째","번째,","범위를","벗어나지만캡처의","변경하여","변경해야","변수","변수는","변수들을","변수로","변수를","변수입니다.매우","변화로","보겠습니다.","보고","보세요.","보이는지","본문","본문에서","본질적으로","볼","부분을","부분이므로","부분인지","분리된","불구하고","불행히도","비","비슷한","빠르게","사라지고","사실만","사용","사용되고","사용되는","사용되든","사용됩니다:","사용법을","사용자가","사용자는","사용하거나","사용하는","사용하려는","사용하려면","사용하면","사용하여","사용하지","사용한","사용할","사용합니다.","사용합니다.(주의사항","사용합니다.화살표","사용해야","사용했어요.","사이에","사항을","사항이라는","사항이며","살펴보겠습니다:","살펴보고","살펴보면서","살펴본","상관없이","상위","상태\"의","상황에","새로운","생략할","생성","생성된","생성된다는","서로","선택","선택적","선택적으로","선택적인","선택하게하세요.","선택하기","선택하면","선택한","선택할","선택합니다.사용자가","선택합니다.이러한","설명하기","설명하는","설명할까요?","설정되는","설정되어","설정할","설정해","소개","소속됩니다.이러한","수","수는","수도","수를","수와","수의","수정하세요:","수행합니다.오버로드","순서를","숫자를","쉽게","스페이스","시간이","시도를","시스템에","신호를","실수를","실행되는","실행하려고","심지어","싶다면","아,","아니라","아니므로","아닌","아닙니다.","아래","악명","않거나","않고","않기","않는","않습니다.","않습니다.실제로","않으면","않을","알게","알고","알려줍니다.하지만","알아야","앞에","앞에서","앞의","애플리케이션에","애플리케이션을","어떻게","언급한","언어입니다.단일","얼마나","엄격모드(strict","없는","없는지","없다는","없습니다!","없습니다.기본","없습니다.컴파일러는","없이","여기서","여기서는","여기에서","여러","여전히","여전히any입니다.왜냐하면","역할을","연결되도록하여","예를","예상합니다.즉","예제를","예제에","예제에서","오는","오류!","오류,","오류가","오류를","오버로드","오버로드가","오버로드로","오버로드를","오버로드만","오버로드합니다.","올바르게","올바른","완벽하게","왔기","외부의","요소입니다.클래스는","요약하면:","원래의","원하는","위에서","위의","위한","위해","유연한","유일한","유지하는","유효한","은닉","의례입니다.typescript는","의미하는","의미하므로","의미합니다.","의미합니다.두","의해","이","이것은","이것을","이러한","이런","이런,","이렇게하면","이를","이름과","이름에","이름은","이번","이야기합니다.때로는","이에","이유","이제","이해하는","이해할","이해해야","익명","인수들을","인수로","인수를","인수의","인스턴스에서","인터페이스를","인해","일반","일부가","일부이며","일이","일종의","일치해야","일회성","읽어보세요.yehuda의","있기","있는","있는지","있도록","있습니다.","있습니다.javascript에서는","있습니다.typescript는","있습니다.그렇게","있습니다.물론","있습니다.왜냐하면","있습니다.이것은","있습니다.이것을","있습니다.이를","있습니다:","있습니다:하나는","있어야","있으며","있으면","있지","있지만","자기","자신을","자체에","자체적으로","작동하는지","작동하며","작동합니다","작성자는","작성하기","작성하든","작성하여","작성할","작성해","작성해보겠습니다.","작성했으므로","작업","작업을","작업하고","잘","장의","재사용하기","적은","적합한","전달되는","전달된","전달하더라도","전달하면","전달하여","전달할","전달했는지에","전에","전체","절충","점은","접근","정도로","정렬되어","정보","제공된","제공하는","제공하지","제공할","제공합니다.","제공했는지","조각은","종류인","좋아요","좋은","주고","주문이","주어진","주어질","주의:","주의사항","주의사항,","줄은","줄일","줄임표","줄임표(...)는","줍니다.","중요한","지정하기","지정합니다.이","직접","집합이기","참조할","찾아내는","찾으면","처리됩니다.rest","처음","첫","체크","초기화된","초기화만","최상위","추가","추가하세요.","추가하여","추가할","추가해보겠습니다.","추론","추론의","추상화","충돌으로","취급되어","취하고","취합니다.pickcard를","카드를","캡처된","캡처하지","캡처할","캡처합니다:","컴파일러가","컴파일러는","컴파일러에","코드를","코드와","콜백","콜백에서","콜백에서의","콜백을","클래스,","클래스와","타이핑(contextu","타입","타입.전체","타입과","타입만","타입에","타입에도","타입에서","타입으로","타입은","타입을","타입의","타입이","타입이어야합니다","타입입니다.","타입입니다.매개변수와","통과","통과할","통해","파악할","파트가","파트는","파트로","표준","표현식에서","표현식을","프로그램을","프로세스를","프로토","필수","필수적인","필요가","필요로","필요하다고","필요하다는","필요합니다.매개변수","하겠습니다","하나","하나는","하나의","하는","하면","하지","한","한다면","한쪽에","한쪽에는","할","할당되는","함께","함수","함수가","함수는","함수라는","함수로","함수를","함수에","함수에서","함수의","함수이든","함수입니다.","함수입니다.예제를","함수처럼","합니다.","합니다.javascript에서","합니다.last","합니다.this.suits[pickedsuit]에서","합니다.그런","합니다.또한","합니다.앞서","합니다.즉","합니다:","항상","해","해결하기","해결하는","해결하려면","해결할","해당","핸들러","핸들러의","했을","형태를","호출","호출되어야한다는","호출된","호출될","호출은","호출을","호출하기","호출하는","호출하면","호출할","혼란스럽습니다.","화살표","화살표(=>)를","확실히","확인한다는","확인해보세요","확인해보세요.","효과적입니다.때문에","후행"],"pages/Generics.html":["\"\";","\"a\");","\"hello","\"m\");","\"mystring\"","\"test\"));","'a'","'b'","'c'","'d'","'m'의","'string'","()","(arg:","(gener","(hello","(introduction)","(use","(x:","+",".length","//","0;","1,","10,","2,","3,","3});","4",":","<>","=","=>","a):","a:","add:","alert(stringnumeric.add(stringnumeric.zerovalue,","anim","any):","any를","api를","arg","arg;","argument","arg에","arg의","array","array):","array는","b:","bee","beekeep","beekeeper;","boolean;","c#","c();","c:","class","classes)","console.log(arg.length);","constraints)","create(c:","createinstance(bee).keeper.hasmask;","createinstance(c:","createinstance(lion).keeper.nametag;","d:","dictionari","dictionary)","echo","extend","function","function(x,","gener","genericidentityfn","genericnumb","genericnumber();","generics)","getproperty(obj:","getproperty(x,","hasmask:","hello","ident","identity(\"mystring\");","identity(arg:","identity;","inference)","interfac","java와","k)","keeper:","key:","length:","lengthwis","lion","loggingident","loggingidentity(3);","loggingidentity(arg:","loggingidentity({length:","member)는","mygenericnumb","mygenericnumber.add","mygenericnumber.zerovalu","myidentity:","nametag:","new","number","number):","number)를","number;","numlegs:","obj[key];","obj에","output","paramet","return","signature로","string","string;","stringnumer","stringnumeric.add","stringnumeric.zerovalu","t","t)","t):","t,","t;","t[]","t[]):","type","types)","typesciprt에서","t}","t는","u","u)","value:","variable)을","variables)","world","world\"","x","y)","y:","y;","zerovalue:","zookeep","zookeeper;","{","{(arg:","{new():","|","}","}):","};","가","가능한","가능해야","가독성","가장","가정을","가정해","가져오려고","가져와","가지","가지고","가진","가질뿐만","각","값을","값이","갖습니다.","같습니다.","같은","같이","객체","객체를","객체의","것","것과","것과는","것으로","것은","것을","것이","것인지를","것입니다.","것입니다.다음장에서는","것입니다.언제","것입니다.여기에서는","것입니다.이렇게하면","것입니다.이를","것입니다.타입에","것입니다.현재의","것입니다:","것처럼","경고를","고급","고정시킬","공학의","관계를","괄호(<>)","괄호(<>)로","구축을","구축하는","그","그대로","그래서","그러기","그저","기능을","기능이","기록하고","기억한다면","길이를","꺾쇠","나열된","나중에","나타내는","나타냅니다.","내부에","넘기면","넘길","네임스페이스는","높일","누군가","눈치","는","다루었던","다룰","다른","다시","다양한","다음","다음에","단일","달리","대신","대응하는","대하여","대한","대해","대해서도","대형","더","더이상","데","데이터","데이터에","도구","도구가","도움이","동일한","동일합니다.(즉","되기","될","됩니다.","됩니다.앞의","두","두가지","두고","두면","두번째","들어","따라","따라서","때","때가","때문에","또는","를","리터럴","리터럴을","마찬가지로","만드는","만든","만들","만들고","만들기","만들면","만들어","만들었습니다.이","매개","매개변수","매개변수(여기서는","매개변수가","매개변수들을","매개변수로","매개변수를","매개변수에","먼저","메소드를","멤버(static","멤버가","멤버를","명령과","명시적으로","명확하고","모듈에는","모든","모릅니다:","모습의","못하면","무엇이","무엇이었는지에","묶인","문자","미래의","및","바꿔보겠습니다.제네릭","바인딩","밖에서","반환","반환될","반환하는","반환할","반환합니다.숫자","반환횔","받고","받을","방법","방법에","방법은","방법을","방법이","방법이기도","방식으로","배열을","배열이며","변수","변수(type","변수가","변수에","변수의","변수인","보겠습니다.","보고","보다","보다는","보면","복잡한","본","볼","봅시다.그러면","봅시다.이","부분은","부여해야","분명히","비","비슷하게","비슷한","비슷합니다.제네릭","뿐만","사용","사용되는","사용이","사용자가","사용자는","사용하고","사용하기","사용하는","사용하도록","사용하여","사용할","사용합니다.자세히","사용합니다.즉","사용했습니다.","사이에","사이의","사항을","살펴보겠습니다.","삽입해야","삽입해야하는지를","생각하면","생성자","생성하는","생성할","선언과","선언할","설명하겠습니다.우리가","설명하겠습니다:","설명하는","설명하는데","설정합니다.","설정합니다.타입","섹션에서","소개","소프트웨어","속성을","속성이","수","수는","수도","수와","숫자","숫자를","스타일에","시스템","시작할","실제로","싶다면","싶을","아니라","아닌","아래의","안과","안에","않는","않도록","않습니다)","않습니다.","알","알고","앞에서","앞의","약간","어떠한","어떤","어떻게","언어에서","언어의","언제","없는","없다고","없다는","없다면","없습니다.","없습니다.이전에","없습니다.컴파일러는","없었습니다.그래서","없음","없음.","에","여기서는","열거형과","예를","예에서","예제는","예제를","예제에서","예제에서는","예제와","오류","오류,","오류가","오류를","올바르게","옮깁니다.","와","외에도","요구","우선","원했지만","위한","위해","위해서는","유연성을","유연한","유용한","유지하는","유형(예:","으로","을","의","의해","이","이것은","이것을","이나","이동하려고","이러한","이렇게","이름","이름을","이미","이전","이전의","이제","이해하는","인수","인수로","인수를","인수에는","인수와","인스턴스","인터페이스","인터페이스로","인터페이스를","인터페이스와","인터페이스의","일관된","일반적으로","일반적이라고","일반적인","일부로","일부인","일치하다면","잃어버리지","잃어버립니다.만약","입니다.","있게","있게되지만","있게합니다.","있고","있기","있는","있는지에","있다고","있다는","있도록","있습니다.","있습니다.ani","있습니다.loggingident","있습니다.예를","있습니다.이것은","있습니다.이렇게하면","있습니다.이를","있습니다.제네릭","있습니다.첫번째","있습니다.하지만","있습니다:","있어야","있으면","있으므로","있을","있음을","있지","있지만","자동으로","자신만의","자체에","자체의","작동하는","작동하도록","작동하지","작성하게","작성할","작성해야","작업하는","잘","잡아내지","장에서는","재사용","적어도","적용할","전달","전달된","전달하는","전달하면","전달할","전달해야","전체","접근하기를","정보도","정보를","정적","정적인","정하는","정했으며","제공한","제공할","제네릭","제네릭에서","제네릭으로","제네릭을","제네릭의","제네릭이","제네릭이므로","제네릭인지","제약","제약으로서","제약조건","제약조건에서","제약조건을","제한되는","제한되어","제한을","제한하는","제한합니다.","조건을","존재하지","종류의","주요","주지만","줍니다.","중","즉","증명할","지식이","지정된","지정할","직접","짧고","참조해야","챘을","처럼","처리하고자","처리하는","처리한다고","처리할","처음의","첫번째","체크!","추가했습니다.이","추론(type","추론은","추론하고","추론하지","취급힙니다.","측면","측면과","측면에서만","측면의","측면이","캡처하여","컴파일러가","컴파일러는","컴포넌트는","컴포넌트를","코드를","콘솔에","클래스","클래스는","클래스를","클래스에는","클래스의","키워드를","타입","타입(예:","타입과","타입들에","타입만","타입변수","타입에","타입에서","타입으로","타입은","타입을","타입의","타입이","타입이든","통해","특별한","특정","파라미터를","팩토리를","포함한","프로토타입","프로퍼티가","프로퍼티를","프로퍼티에","필수","필요가","필요합니다.여기서는","하고","하고자","하기","하나는","하나로","하나의","하나인","하는","하지","할","할당","할지도","함께","함수","함수가","함수는","함수로","함수를","함수에","함수와","함수의","함수입니다.이는","합니다.","합니다.그렇게","합니다.다른","합니다.또한","합니다.실수로","합니다.여기서는","합니다.즉","해당","해야할까요?","했던","했습니다.따라서","허용하지만","형식에","형식으로도","형식을","형태가","호출","호출과","호출에","호출할","혹은","효과적으로","후"],"pages/Enums.html":["!","!==","\"a\"","\"a\";","\"bar\",","\"baz\")","\"down\",","\"foo\",","\"left\",","\"right\",","\"up\",","\"yes\",","\"직렬화(serialize)\"하는","%,","&,","'!=='","'e.bar'","'e.foo'","'if'","(ambient","(comput","(const","(enum","(enum)","(enums)","(function","(heterogen","(name","(numer","(revers","(runtim","(string","(union","(valu","(x","(그리고","(기본적으로","(다른","(예:","*","*,","*/,","*/];","+,",",","...","/*","/,","//","0","0,","0]","1","1,","100)","100,","1을","2","2,","3","3,","4","=",">",">>,",">>>,","[0","[directions.up,","^","`e`","`x`","b","b,","bar,","booleanlikeheterogeneousenum","b에는","c","c:","caroline\",","circl","circle,","comput","const","const))","constant","declar","differences)가","direct","direction.up","directions.down,","directions.left,","directions.right]","down","down,","e","e)","e.bar","e.bar)","e.foo","e.x","e1","e2","e2의","enum","enum.a;","enum;","enum[a];","enum[enum[\"a\"]","enums)","f(e);","f(obj:","f(x:","fileaccess","foo,","function","getsomevalue(),","infin","interfac","javascript로","javascript의","kind:","left","left,","mapping)","mappings)","member","members)","members)에","message:","name)","nameofa","nan","none,","number","number;","obj.x;","radius:","read","respond(\"princess","respond(recipient:","respons","response):","response.yes)","return","right","right,","runtime)","runtime)이","shapekind","shapekind.circle;","shapekind.square,","shapekind.square;","sidelength:","squar","square,","string,","types)","types)에","typescript는","typescript의","up","up,","value)","var","void","x","x,","x:","y,","ye","z","{","{}));","|,","||","}","})","})(enum","~","~~~~~~~~~~~","~~~~~~~~~~~~~~~~","가","가능합니다.","가지고있기","가질","가질수","각","간단합니다:","간주된다는","간주됩니다.","간주됩니다:","값","값과","값들을","값만","값에","값에서","값으로","값은","값을","값이","같은","같이","개념이지만","객체로","객체를","객체입니다.","검사를","검사했습니다.이","것","것과","것으로","것은","것이","것입니다.","것입니다.결합","것입니다.반대로,","것입니다.열거형은","것입니다.이","결고","경우","경우에","경우에는","계산되지","계산된","계산된(computed)","계산된,","괄호로","구별되는","그렇게","기반","나오는","내부가","는","다른","다음","다음과","다음은","단항","달리","대부분의","대한","대해","더","더한","도움이","독립적으로","동안","동일한","동작은","동작을","된","된다는","될","될것입니다)문자","됩니다.","됩니다.이","두어야","들어","들어,","등장하는","디버깅","따라서","따라야할","때","때떄로","때문에","떄문입니다.","또","또는","라는","런타임","런타임시의","런타임에","로","리터럴","리터럴)","리터럴에","마이너스","만","만드는","만들","말하자면","매핑","매핑(revers","매핑과","매핑을","먼저","멤버","멤버가","멤버는","멤버도","멤버들은","멤버로","멤버를","멤버에","멤버에는","멤버와","멤버의","멤버이며","멤버입니다.","멤버입니다.리터럴","명확한","모두","모든","못하면","묶인","문서의","문자","문자열","문자열과","미묘한","및","바보같은","바이너리","받습니다.","방법입니다.하지만","방출되며","배우지","버그를","번째","변화는","별종","보면,","불투명합니다","비교하는","비상수(non","비슷한","비앰비언트","비용을","사례들을","사실을","사용","사용된","사용은","사용하는","사용하려고","사용하면","사용하여","사용할","사이트에서","상수","상수들을","상수로","상수입니다.","상수입니다.이","상수입니다:","상수초기화되어야","생성된","생성하지","섞일","선언합니다.","설명","성공하면","성공하지","속성","속성으로","속성을","수","수는","수도","숫자","숫자인","쉬운","쉽게","시간에","시스템이","시작합니다.다른","신경","실제","실제로","실행되지","실행될","실행됩니다.하지만","실행시","쓰지","아닌지","아래에","아직","않고","않는","않습니다.","않습니다.(역","않습니다:","않았으므로","않았지만,","않은","않지만","알고있다는","알아","앞의","앰비언트","약간의","언어에서","엄격합니다.열거형의","엄밀히","없거나","없고","없기","없는","없습니다.","없앨","없으면","에러입니다.","엑섹스하고,","여기에서는","여부느이","역","역매핑을","역방향(reverse)","연산자","연산자에","열거","열거형","열거형과","열거형에","열거형에서","열거형으로","열거형은","열거형을","열거형의","열거형이","열거형입니다.아래에","예를","예제에서,","예제에서:","오류","오류!","오직","올","와","완벽하게","완전히","왜냐하면","외에도","요구사항이","우회","원한다면","위에서","유용한","유용합니다.","유효현","으로","은","을","의","의도나","의미가","의미를","의미있고","이","이것을","이렇게","이름과","이름으로","이름을","이름이","이며,","이어서","이유는","이전","이전에","이점이","이후","익숙","인","인라인(inline)되지","인라인(inline)됩니다.const","일반","일부","읽기","읽어야하는","입니다.","있는","있다는","있습니다.","있습니다.const","있습니다.typescript","있습니다.단편적으로","있습니다.문자","있습니다.열거형","있습니다.열거형의","있습니다.즉,","있습니다:","있으며","있음)에","있지만","자동","자동으로","자체가","자체에","자체의","자체적으로","작동합니다.","잘못","잡을","저장하는","적용되는","적용된","적용할","전달","전달하지는","전방향(forward)","접근으로","접근할","접해봤다면","정의된","정의할","정의합니다.","정확한","제거됩니다.const","제공합니다.","조합","존재하는","종종","좋습니다.","중","중요한","중이며","즉,","증가","증가합니다.즉,","지","지시자를","지정됩니다:","집합이","집합입니다.표현식은","차이","차이점","참조","참조는","첫","첫번째는","초기화","초기화가","초기화되지","초기화된","초기화됩니다.상수","초기화를","추가적인","컴파일","컴파일됩니다.다른","컴파일하는","컴파일합니다.","코드가","코드는","코드에서","코드와","키워드를","타임","타입","타입에","타입을","타입이","통합","특수","특수한","특정","평가되는","평가될","표현식","표현식만","표현식에","표현식으로","표현식은","표현식이","표현식입니다:","피하려면","필요가","필요합니다.","하나","하나는","하나일","하위","하지","한,","할","함수에","합니다.","합집합(union)","항상","허용되지","혼합될","확인하는","활용할"],"pages/Type Inference.html":["\"가장","\"다른","\"상황적","(basics)","(best","(contextu","(introduction)","(rhino","//","1,","3;","=","[0,","[new","anim","animal,","animal[]","any)","array)","assertions),","common","console.log(mouseevent.button);","createzoo():","eleph","elephant(),","elephant,","function","function(mouseevent)","function(mouseevent:","inference)에","mouseev","new","null","null];","number","return","rhino(),","rhino,","snake","snake()];","snake)[]","type)","typescript","typescript에는","typescript의","typing)\"","window.onmousedown","x","zoo","zoo:","{","|","}","가","가능합니다.","가장","가지며","각","간단합니다.다음","객체가","객체의","검사기는","것입니다.","결과는","결정할","경우도","경우에","경우에는","계산하는","고려하고","고려해야합니다.여기서는","공유하지만","공통","구성됩니다.이","구조를","그","그렇게","그리고","기본","기본값을","네가지","논의할","다른","단언(type","대부분의","대체합니다.일단","대하여","대한","대해","데","되면","된","됩니다.","두가지","때","때문에","또한","라고","로","리터럴,","많은","매개","매개변수는","멤버를","멤버와","명시적","명시적으로","명시적인","명시해주지","모든","무시됩니다.","문맥적으로","문제를","미묘한","반드시","반환","반환문입니다.상황적","발견되지","발생하지","발생합니다.","방향\"에서도","배열","배열(union","배열에는","배열의","배열이","변수에","변수와","변수의","봅시다.","사용되는","사용됩니다.","사용하여","살펴보겠습니다.","상황적","선택사항","선택이","선택합니다.","선택해야하기","설명합니다.즉","설정하거나","소개","수","수도","수퍼","않습니다.","않았을","않으면","않으므로","알고리즘으로","알고리즘은","암시될","어디서","어떻게","없기","없는","없습니다.이","여러","예:","예시","예에서","예제를","예제에서","오류가","오류는","오류를","오른쪽","와","요소","요소의","우측","원할","위","위의","위치가","위치에","위해","위해서는","유니온","유형을","유형의","은","의","의해","이","이라고","이루어지면","이상적으로,","인수,","일반적인","입력","있는","있면","있습니다.","있습니다.아래","있습니다.하지만","있었습니다.이","있지","작동합니다.이를","작성했다면:","작용합니다.","장에서는","적용되지","적용됩니다.일반적인","정보가","정보를","정해진","정확히","제공되는","제공하기","제공해야합니다:","종류의","주석이","주어집니다.가장","중에서","집합으로","차이에","초기화하거나","추론","추론(type","추론되기를","추론되는지","추론됩니다.이러한","추론은","추론의","추론이","추론하기","추론할","추론했습니다.이렇게","추측을","코드를","코드에서","타이핑(contextu","타이핑은","타입","타입\"을","타입(상위","타입)이","타입에","타입으로도","타입은","타입을","타입의","타입이","타입인","포함되어","표현식,","표현식에","표현식에서","표현식은","표현식의","표현식이","하나도","할","할당의","함수","합니다.상황적","해결하려면","해당","했을","호부와","호출에","호환되는","후보"],"pages/Type Compatibility.html":["\"","\",","\",\"","\"alice\",","\"alice\"});","\"seattle\"","\"seattle\"});","\"타당\"한","'arg'로","'버려지는'","'호환성'을","()","(...args:","(a","(a:","(advanc","(b:","(classes)","(compar","(e).y));","(e:","(enums)","(function","(generics)","(introduction)","(n:","(option","(privat","(start","(subtyp","(x,","(x:","(x?,","(x와","(y:","({name:","(이","(타입","*/","+","...","/*","//","//그래도","0;","2,","2],","3];",":","=","=>","[1,","a:","a;","alert(\"hello,","anim","animal;","any)=>ani","any[])","any[],","any를","any에서와","array#foreach는","array)","assignment)","bivari","bivariance)","blue,","c#","callback:","class","classes)","color","color.green;","console.log((e).x","console.log(e));","console.log(e.x","console.log(item));","console.log(x","constructor(name:","constructor(numfeet:","data:","e.y)));","e.y));","empti","empty;","empty에","enum","event","event)","eventtyp","eventtype,","extend","extends의","feet:","function","function(x:","function(y:","functions)","green","greet(n:","greet(y);","handler:","ident","implements와","index,","interfac","invokelat","invokelater([1,","invokelater(args:","item","items.foreach((item,","items.foreach(item","java","javascript","javascript는","javascript에서","keyboard","keycode:","keyev","listenevent(eventtype.mouse,","listenevent(eventtype:","locat","location:","member","mouse,","mouseev","mouseevent)","n.name);","name","name:","named)","named;","new","note","notempti","notempty;","number","number)","number,","number;","numfeet:","out)","overloads)","p","p:","paramet","parameters)","person","person();","privat","private와","protect","ready,","red,","rest","revers","reverse;","s","s:","s;","safety)","size","size;","soundness)","statu","status.ready;","string)","string,","string;","t","t):","t;","timestamp:","topics)","two","typescript","typescript는","typescript에서","typescript의","u","u):","undefined가","void)","void>((e:","vs","wait","x","x:","x;","x가","x는","x에","x와","x의","y","y)","y));","y:","y;","y?)","y가","y는","y에","y에는","y에서","y와","y의","{","}","};","가능하거나","가능하지만","가능한","가능합니다.","가져야합니다.","가져온","가지","가지고","가지므로","가진","가질","각","간단하지만","간단한","간주되어야","간주됩니다.","값은","값을","강제로","강제합니다.","같기","같은","개념은","개의","객체","객체를","객체의","거에요!","검사하기","검사하여","검사할","검사합니다.","검사합니다.그","검사합니다.그런","것으로","것은","것이","것입니다.","결과","결과로","결정됩니다.","경우","경우x의","경우에도","경우와","계층","고급","고려되지","고려됩니다.","고려됩니다.이","고려했으며","곳과","곳을","관계시키는","관계의","관점에서","광범위하게","괜찮을","구성원","구조","구조가","구조와","구조의","구조적","구조적인","구현체로","규칙과","규칙은","규칙이","그","그것은","그럼에도","그렇기","기반으로합니다.구조적","기본","기본적인","기술하지","나머지","나타나는","내용은","노트","다른","다음","다음과","대부분의","대상","대상의","대신","대신에","대안","대조적입니다.","대한","대해","더","덜","동기","동기를","동일하게","동일한","동작을","동작하는지","동작합니다.","될","두","뒤에있는","드물기","들어","들어:","따라","때","때문에","때문입니다.","또는","라이브러리에서","런타임","리터럴","리터럴과","마세요","마찬가지로","만","많은","매개","매개변수","매개변수는","매개변수를","매개변수의","매우","먼저","메커니즘","멤버","멤버가","멤버는","멤버를","멤버만","멤버에","멤버의","명사적인","명시된","명시적으로","모두","모든","목록에서만","목록을","목적을","무시하는","무한적입","문서","문자열인","미치지","및","바꿔서","바람직하지","반대일","반환","발견","발견되는","발생하는","방법을","방법입니다.이것은","방식에","방식으로","배열","번째","변경하면","변수","변수가","변수는","변수는y에","변수를","변수에","변수와","변수의","별도의","보면","보여줍니다","복잡합니다.","부여","부여하는","부적절하지만","부적절한","부적절함","불구하고","비","비교","비교됩니다.정적","비교적","비교하는","비교할","비롯된","사양에","사양을","사용될","사용됩니다","사용하기","사용하는","사용하면","사용하여","사용하지","사용할","사용합니다.실용적인","사용했습니다.typescript에는","살펴보겠습니다","살펴보겠습니다:","살펴보세요","살펴봅니다.","상당히","상속","상응하는","상황에","상황에서","상황이","생기는","생성된","생성자는","서로","서브","선택적","설계되었습니다.","설명합니다.","성공합니다.","세","소개","소스","수","수도","수의","수퍼","수행하고","수행할","숨겨진","숫자","숫자는","숫자와","시그니처과","시나리오에","시스템","시스템에","시스템에)","시스템은","시스템을","시스템의","시스템이기","시작하기","식으로","신중하게","실제로","아니라고","아니라는","아니며","아닌","아닙니다.","안전성(type","안전성에","안전하게","안정성에서","않기","않는","않습니다","않습니다(명확한","않습니다.","않습니다.왜냐하면","않으며","않으므로","않은","않지만","알","어떻게","언어","언어에서는","없기","없는","없습니다.","열거형","열거형과","열거형까지","열거형에서","열거형은","열거형의","영향을","예를","예시와","예외를","예제:","예제는","예제를","예측","오류","오류).","오류,","오류가","오류는","오류입니다.","오버로드","오버로드가","오버로드는","완료시","완전히","왜냐하면","요소와","용어가","우선","원본","원시적인","위의","위치는","위치에서","위한","위해","유사하게","유용합니다","유의한다.","유익하고","유형에","유형을","유형의","의심스러울겁니다.이","의해","이","이것은","이는","이러한","이런","이로","이를","이름뿐인","이름은","이유가","이유는","이제","익명의","인덱스","인수","인수를","인스턴스","인스턴스가","인스턴스에도","인스턴스의","인터페이스와","인터페이스의","인해","일반적으로","일반적이지","일반적인","일부(개발자에게)","일부로","일이기","일치","일치합니다","일치해야합니다.이렇게하면","임의의","입니다","있기","있는","있는지","있는지를","있다.","있다면","있습니다\"","있습니다.","있습니다.원본","있습니다.타입","있습니다:","있어","있어야합니다.마찬가지로","있으면","있지만","자세한","자신을","자연스럽습니다.","작동합니다:","작성된","작업을","잘","재귀적으로","적어도x와","적용되는","적용되지","적용됩니다.이를","전체에서","점에","정말로","정의된","정적","제공\"할","제공하게","제공하는","제공합니다","제네릭","제외하고","좀","종류에","종류의","좋아요","좋아요,","주제","줍니다.","줍니다.클래스의","중","중요하지","지금까지는","지정되지","지정하는","지정하여","진행되어","질문은","집합인것처럼","차별화된","차이가","참조하십시오.","찾습니다.","처리됩니다.","처리하는","첫","추가","추가적인","추가하여","추론된","취하는","측에서","컴파일러는","코드가","코드를","콜백","콜백을","클래스","클래스가","클래스는","클래스에서","클래스에서는","클래스와","클래스의","타이핑과","타이핑은","타이핑이니까","타입","타입과","타입를","타입만","타입에","타입은","타입을","타입의","타입이","타입이되도록","타입처럼","탐색합니다.","통과하는","통해","특수화된","특정","패턴을","패턴입니다.","포함되어","포함된","포함합니다.","표현식이나","표현하는","프로세스는","프로퍼티가","프로퍼티를","필수","필요로","필요합니다)","하나를","하는","하위","하지","한","한가지","할","할당","할당과","할당될","할당을","할당이","함수","함수가","함수를","함수에","함수와","함수의","합니다.","해당","허용되는","허용되지","허용됩니다.","허용하는","허용하는지","형태을","호출","호출하는","호출한","호출할","호출합니다.","호환","호환가능한","호환되는","호환되며","호환되지","호환된다는","호환됩니다.다른","호환성","호환성에","호환성은","호환성을","호환성이","혼란스러움","확인하기","확장에서만","훨씬","흔한"],"pages/Advanced Types.html":["!","!==","\"","\")","\");","\"10억","\"bar\";","\"bob\";","\"boolean\",","\"circle\":","\"circle\";","\"default\";","\"eas","\"foo\";","\"img\"):","\"input\"):","\"number\")","\"number\",","\"number\";","\"number\"를","\"padding\"을","\"rectangle\":","\"rectangle\";","\"square\":","\"square\";","\"string\")","\"string\",","\"string\";","\"symbol\".typescript에서","\"triangle\"을","\"typename\",","\"typename\"와","\"typename\"은","\"uneasy\");","\"uneasy\"가","\"리터럴","\"싱글톤","&","'","'!=='는","'\"eas","'\"uneasy\"'","'${padding}'.`);","'.","'1'과","'2'","'address'로","'age'","'age');","'age'에","'age'와","'fly'","'jarid',","'name'","'name');","'name'이","'null'은","'number","'number'에","'option1'","'option2';","'padding'이","'string","'string'에","'swim'과","'undefined'는","'undefined'를","'unknown');","'unknown']);","'unknown'은","(!result.hasownproperty(id))","((pet).swim)","()","(const","(discrimin","(eas","(enum","(exhaust","(first)[id];","(index","(infer","(instanceof","(intersect","(isfish(pet))","(isnumber(padding))","(isstring(padding))","(let","(numer","(option","(pet).fly();","(pet).swim","(pet).swim();","(pet.fly)","(pet.swim)","(polymorph","(result)[id]","(s.kind)","(second)[id];","(sn","(string","(type","(typeof","(union","(user","(x","(y","(다른","*","**","*/","*=","+","+=","..","...",".add(1)",".currentvalue();",".multiply(5)",".sin()","/**","//","0)","0);","0,","1","1).join(\"","12;","13;","1이어야","2","2)","2);","2;","2와","3","35","4","4);","5","6",":","=","==","===","=>","['age',","['name']);","[k","[key:","[p","a:","access","add(operand:","address:","age:","age?:","alia","alias","alias):","alias;","aliased(arg:","aliased는","aliases)","aliases)은","aliases는","aliases도","aliases를","aliases와","aliases은","aliases을","aliasing(typ","alias가","alias를","alias에","animate(dx:","any)","any):","any가","any로","area(s:","area도","array(pad","array(this.numspac","array;","assertions)","assertions)을","assertnever(s);","assertnever(x:","assertnever는","b","b?:","basiccalcul","basiccalculator(2)","basiccalculator를","bend","bird","bird):","bird가","bird는","body가","boolean","boolean;","boolean은","boolean이므로","broken(name:","button","button.animate(0,","c","c();","c.a","c.b","case","case가","checking)","circl","circle;","class","consolelogg","consolelogger());","constructor(priv","constructor(protect","constructor(publ","constructor(valu","contain","createelement(tagname:","currentvalue():","declar","default:","defin","differenti","discrimin","discriminant.","dy:","eas","easing)","easing:","element","epithet;","error(\"unexpect","error(`expect","extend","extend(first:","extend(new","f","f(1);","f(1,","f(sn:","f(x:","first)","fish","fish가","fish는","fish라는","fish의","fixed(name:","flag","fli","fly();","fly라는","foo(x:","function","get():","getname(n:","getpaddingstring()","getpaddingstring():","getproperty(o:","getproperty(person,","getproperty라는","getproperty에서,","getproperty의","getrandompadder()","getsmallpet():","getsmallpet();","guard","guard)는","guards)","guard라는","height:","hello","htmlimageelement;","htmlinputelement;","id","identifier!는","identifier의","implement","in\"","in\")","in\");","indentedstr","index","instanceof","instanceof의","interfac","interface):","interface;","interfaced(arg:","interface를","isfish(pet:","isfish가","isnumber(x:","isstring(x:","javascript","javascript에서","javascript의","jim","jim.log();","jim.name;","k","k):","k[]):","k]:","key","keyof","keyof를","keyof와","keys:","keys]:","keys는","kind","kind:","k는","layeggs();","left:","linkedlist","linkedlist;","liter","log()","log():","loggabl","loggable은","map","map;","map['foo'];","math.pi","math.random()","math.sin(this.value);","member","mind","mixin을","multiply(operand:","multiply는","n","n();","n;","name","name!.charat(0)","name.charat(0)","name:","name?:","nameorresolv","nameorresolver):","nameresolv","nameresolver;","names)","names.map(n","names:","name의","name이","never","never):","new","next:","null","null'에","null)","null):","null);","null;","nullabl","nullableperson","null과","null과는","null은","null을","null일","num:","number","number)","number):","number,","number;","number를","number이거나","number인","numspaces:","o:","o[n]);","o[name]:","o[name];","o[name]은","object:","ok","operand;","operator)","option1:","option2:","originalprop","out\"","out\"'","out\")","out\";","pad","padder","padding:","padleft","padleft(\"hello","padleft(value:","padleft의","paramet","parameternam","parametername은","partial","partial.name은","partial;","partialperson","partial과","partial는","partial처럼","people.name;","people.next.name;","people.next.next.name;","people.next.next.next.name;","people:","person","person(\"jim\"),","person.name이","person:","person;","person['name']은","person['name']타입을","person[p]","person]:","person]?:","personparti","personprops:","personreadonli","person에","person은","person의","pet","pet.fly()","pet.fly();","pet.layeggs();","pet.swim();","pet의","pet이","pick","pick과","pick은","pluck(o,","pluck(o:","pluck(person,","pluck과","pluck으로","postfix(\"great\");","postfix(epithet:","predicate)","properties)","prototyp","proxi","proxifi","proxify(o:","proxify(props);","proxify):","proxy;","proxyprop","public","radius:","readonli","readonly,","readonly;","readonlyperson","readonly를","readonly와","record","record는","record와","rectangl","result","result;","result[k]","return","right:","rolldie():","s","s.height","s.radiu","s.size","s.size;","s.width;","scientificcalcul","scientificcalculator(2)","scientificcalculator는","scientificcalculator입니다.","second)","second:","serializ","set(value:","shape","shape)","shape):","shape에","signatures)","sin","sin()","size:","sn","sn:","sn;","spacerepeatingpadd","squar","strictnullchecks가","strictnullchecks를","strictnullchecks에서","strictnullchecks와","string","string)","string):","string,","string;","string[]","string]:","stringpadd","strings:","string을","string이","string인","string입니다.","super(value);","swim();","switch","switch가","s가","t","t)","t):","t,","t;","t[k]","t[k],","t[k].get();","t[k][]","t[k]는","t[k]를","t[p]","t[p];","t[p]가","t[p]의","t[string]은","t]:","t]?:","tag","tag라고","this.valu","this.value;","this;","this는","this를","threestringprop","throw","tree","tree;","triangle;","triangle을","true);","type","typeof","types)","typescript가","typescript는","typescript에는","typescript에서","typescript의","types의","type과","type에서","type은","t는","t를","t에","t와","t으로","t의","t이며","u","u):","uielement","uielement();","undefin","undefined'에","undefined);","undefined;","undefined가","undefined는","undefined라는","undefined로","undefined를","union","union.","unions)","unions,","unions은","unions합니다;","unknown","unproxify(proxyprops);","unproxify(t:","v","value:","value;","var","void;","vs.","width:","world\"","world\",","x","x);","x는","y?:","yike","{","{}","{};","|","||","}","};","~~~~~~~","—","가능하다면","가능한","가드","가드(type","가드.","가드는","가드로","가드를","가드와","가드임을","가장","가져가면","가져와서","가지","가지게되고","가지고","가지는","가진","가집니다","가집니다.","각","간결하다는","간단하고","간단한","간략하게","간주합니다.사실상","감싸기","값에","값을","값의","값이","값입니다.즉","갖게됩니다.","갖는","갖춘","같습니다.","같습니다:","같은","같이","개념을","개수의","객체","객체는","객체에서","거의","검사","검사를","검사하기","검사하도록","것과","것들이","것에","것으로","것은","것을","것이","것입니다","것입니다.","것입니다.multiply는","것입니다.그러나","것입니다.그리고","것입니다.다행히도","것입니다.이는","것입니다.즉","것입니다.타입","것입니다:","결과","결과를","결과적으로","결합","결합됩니다.이러한","결합하여","결합할","결합합니다.따라서","겹칠","경우","경우는","경우에는","경우에도","경우조차도","계산기가","계층을","계층적으로","고급","고유합니다.인터페이스는","고전적인","고통스럽습니다.다행스럽게도,","곳에","곳입니다:","공백이","공통","공통적인","과","관련이","괜찮습니다.","굉장히","교차","교차(intersection)","구문과","구문은","구별하기","구별하는","구분하기","구성","구성요소가","구체적으로","구현되기","구현할","그","그것을","그러나","그런","그럼","그렇지","그리고","기능을","기대하는","기반으로","기본","기존","기존의","기타","까다로울","꽤","나갑니다:","나뉩니다:","나타나는","나타냅니다.이것을","남겨진","내부가","내에서","낸다는","넣습니다:","누락된","다루고","다루지","다르게","다른","다시","다양한","다음과","다음에서","다음으로","다음은","다형성의","다형성의thi","다형성이라고","단서는","단언","단언(type","단언을","단일","단지","단지string이","달라집니다.","달러의","대수의(algebraic)","대신","대한","대해","대해서","더","데","데는","데이터","도움이","돌아와","동안,","동일한","동일합니다:","동작을","동적","동형","동형(homomorphic)이","동형(homomorphic)이기","동형(homomorphic)인","동형이","되지","될","됩니다","됩니다.","됩니다:","두","두가지","들어","들어,","들어:","들어있는","따라","따라서","때","때때로","때문에","때문입니다.함수가","또","또는","또는string이","라이브러리를","라이브러리에","래핑된","래핑하는","런타임","런타임에는","리스트이고","리터럴","리터럴로","리턴합니다.","마우스를","마찬가지로","막대(|)를","만드는","만들","만들어","만들어야","만들지","많습니다!)","많은","말하면","맞지","매개","매개변수에","매개변수와","매우","매핑","매핑은","먼저","멈추지는","메서드가","메서드로","메서드를","메시지는","멤버","멤버가","멤버는","멤버를","멤버에만","멤버의","명백하기는","명시적","명시적으로","명제","명제로","명제입니다.명제는","몇","모델링","모두","모든","목록은","못하고","못하면","무슨","무엇인지","문서의","문자열","문자열과","문자열에","문자열에서","문자열은","문제점은","미리","미묘하며","미묘한","믹스인에","밀접한","및","바꿔","바운드","바인딩","반드시","반면","반복할","반영합니다.","반환","반환된","반환하는","반환하면","반환한다는","반환할","반환했을","발명가","발생시킵니다.","발생하여","발생합니다","발생합니다.그러나","발생해야합니다","발휘되는","방법으로","방법은","방법을","방법이","방법입니다.","방법입니다.예를","방식으로","방식으로든","방지하려는","버그를","버전에","버전을","버전의","번","번째","번째는","범위를","변경","변수","변수가","변수는","변수를","변수에","변수와","변수의","변형을","변형입니다.이것은","변환은","변환합니다.예를","변환합니다.즉","별칭","별칭을","보여","보여주지만","보여줍니다.","보입니다.기존의","보장된","보장하는","보통","복사하는","복사할","본질적으로","볼","부릅니다.","부릅니다.다른","부분을","분류된다는","분명해집니다.","불가능합니다:","비교를","비교하는","비교할","빌드할","뿐만","뿐입니다.어떠한","사용되는","사용될","사용됩니다.때로는","사용됩니다.세","사용법이","사용을","사용자","사용자가","사용하겠지만","사용하기","사용하는","사용하려는","사용하려면","사용하려면:","사용하면","사용하므로","사용하여","사용하지","사용한다는","사용할","사용합니다(즉시실행함수","사용합니다:","사용해야","살펴보겠습니다:","상호","상황을","새로운","생깁니다.이","생성된","생성자","생성하기","생성하지는","생성합니다.원시","생성합니다.타입","서브타입","선언의","선언할","선언합니다.각","선택적","선택적으로","선택적입니다.다음은","선택하고","선택하는","설명합니다.각","설정할","세","섹션에","섹션에서","소개합니다.","소프트웨어의","수","수는","수도","수동으로","수있는","수정할","수직","수행하는","수행하십시오:","순서로","숫자","숫자/문자열","쉽게","쉽습니다","스코프에서","스코프에서는","스코프의","시","시간","시그니처","시그니처과","시그니처에","시그니처을","시그니처의","식별","실수\"라고","실시하면","실제","실제로","실질적으로","실패합니다.","실행될","실행하게","싱글톤","아니라","아니라,els","아닌","아닙니다.","아마","아무거나","안","않기","않는","않는다는","않도록","않습니다","않습니다.","않습니다.record가","않습니다.아래","않습니다.유니온","않습니다.컴파일러는","않습니다—","않았습니다","않은","않을","않지만","알","알고","알기","알려주면","알려진","알아내는","알아야","알았으므로","알지","앞서","애플리케이션은","약간","약간의","어디에서","어디에서나","어떤","언급했듯이","언급했듯이,","언급했었습니다.기본적으로","언래핑","언래핑(푸는)","언어는","언어에서는","얻을","업데이트된다는","업데이트해야","없고","없기","없는","없는basiccalculator를","없다는","없습니다","없습니다).왜냐하면","없습니다.","없습니다.null의","없습니다.그것들을","없습니다.런타임에","없습니다.즉","없었다면","없었을","없으며","없이","에디터의","에러가","여기서","여기서,","여기에","여러","역할을","연산은","연산자","연산자(index","연산자는","연산자도","연산자를","연산자에","연산자입니다.어떤","열거형","열거형과","열려있다","예를","예제가","예제는","예제를","예제에서","예제에서는","예제입니다:","오래된","오류","오류!","오류,","오류:","오류가","오류를","오른쪽에","오른쪽에는","오버로드","오버로드를","올바른","와","완만한","완전하지","완전히","외부","왼쪽에","요소에","요청하는","용어는","원래","원시","원시적인지","원할","위","위로","위의","위한","위해","유니온","유니온,","유니온으로","유니온을","유니온의","유니온이나","유니온입니다.","유사","유사하게","유사하지만","유용하기","유용하지","유용할","유용합니다.","유용합니다.fish를","유용합니다.일부","유지할","유효하지","유효한","을","의미론과","의미합니다.","의미합니다.일단","의미했습니다.이","의해","이","이것들의","이것은","이것을","이들은","이때","이러한","이름들의","이름을","이름의","이름이어야","이며","이미","이상","이상적인","이야기할","이와","이전","이전의","이제","이제는","익숙하다면","익숙해지는","인","인경우","인덱스","인라인","인수를","인수와","인스턴스화하므로","인식됩니다:","인식하기","인식하지","인터페이스가","인터페이스는","인터페이스로","인터페이스를","인터페이스에","인터페이스와","인터페이스의","일반적인","일반적일","일부","일어날까요?javascript에서","일은","일이","일치하도록","읽기","읽었고","입니다.","입니다.즉","입니다:","입력","있는","있는지는","있는지에","있다는","있다면","있습니다","있습니다.","있습니다.(javascript에","있습니다.:","있습니다.discrimin","있습니다.kind","있습니다.string","있습니다.각각의","있습니다.구문은","있습니다.명시적","있습니다.실제로","있습니다.아래","있습니다.예를","있습니다.이","있습니다.이것을","있습니다.이것이","있습니다.타입","있습니다.하지만","있습니다:","있어야","있으며","있으면","있을","있음을","있지만","잊어버렸을","잊어버리면","자동으로","자주","자체적으로","작동하는","작동하도록","작동합니다.매핑된","작성되는","작성된","작성하고","작성하는","작성할","작성해보겠습니다.다음과","작성해야","작업은","작용하고","작용합니다.문자열","잘","잡는","적용","적용되고","적용되지","전달할","전달했는지","전에","전용","전용인","전통적인","점","점은","점이다.그리고","점입니다.","점입니다:","접근","접근법은","접근은","접근할","정의","정의하기만","정의하는","정의하려면","정의해야","정확한","제거되었습니다.case를","제거하는","제거할","제거합니다:","제거해야","제공합니다.","제공합니다.map","제외).특히","제한할","존재를","존재하는","좀","좁혀","좁히는","종료된","종류의","종류일뿐입니다:","좋겠습니다.예를","좋습니다.","좋아요","좋아요,","좋은","좋지만","주는","주목하세요.일단","중","중요한","중첩된","즉","지나치기도","지점에서","지정자를","지정하는","지정할","지정해야","지향","직관이","직접","진행됩니다.","집합을","차례대로","차별된","차용해보겠습니다:","차이점은","차이점이","참조하기","참조할","참조합니다","철저한","철저히","첫","체커는","체크가","초기화될","추가","추가됩니다.","추가하기","추가하면","추가하여","추가합니다.","추가합니다:","추론","추론은","추상화","추상화할","추적할","취하는","취할","취합니다,","컨텍스트에서","컴파일","컴파일러가","컴파일러는","컴파일러에서","켜고","코드가","코드는","코드를","코드에서","코드에서,","코드에서는","코딩된","쿼리","쿼리와","클래스나","클래스는","클래스에","키의","타임에는","타입","타입\"과","타입\"에","타입\"을","타입,","타입.","타입과","타입도","타입라는","타입를","타입뿐만","타입에","타입에는","타입에서만","타입으로","타입은","타입을","타입의","타입이","타입인","타입인지","타입입니다","타입입니다.","템플릿입니다.왜냐하면","토니","통과되지만","통과해서는","튜플","특별한","특성을","특성이","특정","파트로","패턴은","패턴을","포함되어","포함되지","포함된","포함될","포함할","포함합니다.","표준","표현식을","표현식입니다.타입","표현할","프로그래밍에","프로퍼티","프로퍼티는","프로퍼티를","프로퍼티에","프로퍼티에는","프로퍼티에만","프로퍼티에서","프로퍼티의","프로퍼티인","프로퍼티인지","필드를","필요가","필요는","필요한","필요할","하고","하나는","하나로","하나의","하나일","하는","하드","하려면","하며","하면","하위","하지만","한가지","한편으로는,","할","할당","할당되지","할당할","함께","함수","함수가","함수로","함수를","함수에","함수에서","함수을","함수의","함수형","합니다","합니다.","합니다.padleft의","합니다.다른","합니다.다행히","합니다.세가지","합니다.여기","합니다:","합집합을","항목에","항상","해당","해야","핸들링하지","했다는","허용되는","허용되지","현재","형식에","형태로","형태를","형태을","호어는","호출되는지","호출될","호출은","호출을","호출한","호출할","호환","호환됩니다.차이점은","확실히","확인하는","확인합니다","확인합니다.이","확인합니다:","확장/구현할","확장에","확장하거나","확장하지도","확장할","후에","후위에","훨씬","힘이"],"pages/Symbols.html":["\"c\"","\"c\";","\"value\"","(introduction)","(well","//","2015에서","=","===","[getclassnamesymbol](){","[sym]:","array.prototype.concat에","boolean","c","c();","c[getclassnamesymbol]();","class","classnam","console.log(obj[sym]);","const","ecmascript","false,","getclassnamesymbol","instanceof","known","new","number와","obj","primit","return","string","string.prototype.match","string.prototype.replac","string.prototype.search","string.prototype.split","string같은","sym","sym1","sym2","sym3","sym3;","symbol","symbol(\"key\");","symbol();","symbol.hasinst","symbol.isconcatspread","symbol.iter","symbol.match","symbol.replac","symbol.search","symbol.speci","symbol.split","symbol.toprimit","symbol.tostringtag","symbol.unscop","symbols)","symbol은","toprimit","{","}","};","가지는","값으로","값은","값을","값입니다.","갖는","객체","객체가","객체는","객체를","객체의","결합하여","계산된","고유합니다.","구문에","기본","나타내는","내부","내장","다음은","대체하는","데","데이터","동작에","동작을","됩니다.","마찬가지로","만드는","메서드object.prototype.tostring로","메서드로","메서드에","메서드입니다.","멤버를","목록입니다.","문자열","문자열과","문자열에서","문자열을","문자열의","바인딩에서","반복자를","반환하는","방법입니다.","배열","변환하는","병합되어야","부분","분할하는","불변이며","비교하는","사용되는","사용됩니다.","사용자","사용할","생성됩니다.","생성자","생성자를","생성자의","선언과","선언할","선택적","설명을","소개","수","수도","시작된","심볼","심볼은","심볼을","심볼이","알려진","언어","여부를","연관된","연산자의","외에도","요소로","의미로","의해","이름\"을\"","이름입니다.","인덱스를","인덱스에서","인스턴스","인식하는지","일치하는","있습니다.","있습니다.내장","자신의","잘","정규","정규식","정규식과","정의","제외되는","중","추상","클래스","키","키로","타입입니다.","파생된","판단하는","표현식","표현식과","표현식을","프로퍼티","프로퍼티와","프로퍼티의","프로퍼티입니다.","하나로서","함수의","함을","합니다.","해당하는","호출","호출됩니다.","호출하여","환경"],"pages/Iterators and Generators.html":["\"0\",","\"1\",","\"2\",","\"4\",","\"5\",","\"6\"","\"cat\",","\"dog\",","\"hamster\"","\"hamster\"]);","\"mammals\";","\"species\"","\"string\",","(iterables)","(let","(statements)","(target","(var","//","0;","1,","2,","2015","3];","5,","6];",":","=","[1,","[4,","_i","array","console.log(entry);","console.log(i);","console.log(num);","console.log(pet);","ecmascipt","ecmascript","entri","es3)","es3를","es3와","es5","fals","false];","for..in","for..in은","for..of","for..of는","for..of와","higher)","int32array,","iterable로","list","list)","map,","map과","new","num","number","numbers)","pet","pets)","pets[\"species\"]","set","set([\"cat\",","set,","somearray","somearray)","string,","symbol.iter","uint32array","var","vs.","{","}","가능한","가지고","간단한","간주됩니다.array,","값","값에","값에만","값은","같은","같이","객체는","객체에","객체에서도","객체의","검사하는","것을","것입니다.","것입니다.이","관심이","구현된","구현을","구현합니다.","내장","내장객체는","는symbol.iter","다르지만,","다른","다음과","다음은","담당한다.","대상","대상으로","대한","대해","들어","등과","때","또","또는","루프를","루프입니다:","를","리스트를","몇몇","모두","목록을","문","반면","반복","반복되는","반복자","반복자는","반복하며","반복할","반복합니다.반복되는","반환하는","반환합니다.","방법으로","배열의","보여","사용됩니다.한편","사용할","생성","생성됩니다","생성할","생성합니다.","수","숫자(numeric)","어떠한","엔진에서","엔진을","예를","예제입니다:","위한","을","이러한","이미","이상","이터러블","이터레이터와","있게","있는","있습니다.","작동한다는","저장된","접근할","제네레이터","주는","주로","차이를","차이점은","컴파일러는","코드","키","타입은","타입의","프로퍼티를","프로퍼티에","프로퍼티의","하고","할","함수는","해","호출합니다.","호환"],"pages/Modules.html":["!==","\"","\"*!text\"","\"*\":","\"+\":","\"./calculator\";","\"./lettersonlyvalidator\";","\"./mi","\"./mod\";","\"./mod\"],","\"./myclass\";","\"./myfunc\";","\"./mylargemodule.ts\";","\"./mythings\";","\"./onetwothree\";","\"./programmercalculator\";","\"./staticzipcodevalidator\";","\"./stringvalidator\";","\"./validation\";","\"./xyz.txt!text\";","\"./zipcodevalidator\";","\"/\":","\"0\"","\"001+010=\");","\"1\",","\"1+2*33/11=\");","\"101\"];","\"123\"","\"123\";","\"2\",","\"3\",","\"4\",","\"5\",","\"6\",","\"7\",","\"8\",","\"9\",","\"98052\",","\":","\"=\")","\"a\",","\"ambient\"으로","\"b\",","\"c\",","\"d\",","\"doe","\"e\",","\"exports\",","\"f\"];","\"function\"","\"hot","\"jquery\";","\"json!*\"","\"json!http://example.com/data.json\";","\"matches\"","\"math","\"module\"","\"next","\"object\"","\"object\")","\"path\"","\"thing\";","\"url\"","\"url\";","\"네임스페이스\"입니다.\"외부(external)","\"모듈\"입니다","\"발견\"","\"최상위","$","$(\"button.continue\").html(","$:","$;","${","${validate(s)","$가","$나","&&","'${char}'`);","'lettersonlyvalidator'","'stringvalidator'","'zipcodevalidator'","'위로'","(...args:","(amd),","(base","(char","(code","(commonjs),","(default","(digit","(do","(dynam","(es6)에","(explicitli","(export","(export)","(factory)","(foo를","(function","(guidanc","(if","(import","(let","(mod_1_1)","(needzipvalidation)","(option","(programmercalculator.digits.indexof(digit)","(re","(red","(require,","(require를","(s:","(simpl","(simplifi","(this.operator)","(typeof","(use","(v","(validator.isacceptable(\"...\"))","(valu","(work","(x.isacceptable(\"...\"))","(zipcodevalidator:","(글로벌","(이것들이","(즉",");","*","*/","+","...",".d.t",".h파일로",".j","/","/*","//","///","/^[0","/^[a","/collections/generic/","0","0)","0;","1);","1.5에서는","10이","16","1;","2015","2015부터","2015와","2015의","3","5","9","9]+$/;",":","=","===","=>","=를",">=","?","[\"0\",","[\"hello\",","[s:","access","advanc","allvalidators.t","ambient","amd","amd를","any;","any[])","any[]):","api","api를","app.t","base:","boolean;","c","c#에서는","calcul","calculator();","calculator(2);","calculator,","calculator.t","case","cat","class","close","code\"]","commonj","commonjs를","commonjs모듈","commonjs와","console.log(`\"${","console.log(`\"${s}\"","console.log(data,","console.log(f());","console.log(num);","const","constructor()","constructor(publ","consumer.t","content:","content;","current","currentvalu","currentvalue:","data","declar","declaration)","declarations.d.t","default","default)","default를","defin","define([\"require\",","define,","define.amd)","digit","dog","ecmascript","effect","entir","error(\"bas","error(`unsupport","evaluate()","evaluateoperator(operator:","example)","excerpt)","execute:","export","export)는","exports)","exports);","exports,","exports.t","exports_1(\"t\",","exports가","exports는","exports는이","exports도","exports로","exports를","exports에","export가","export된","export로","export를","export만","export의","export인","export하는","extend","extend)","extensions을","f","factory(require,","factory);","filecont","filecontent);","flags)","flower","foo","function","function()","function(exports_1)","function,","function가","function만","gener","getresult()","getthing()","handelchar(char:","hostname?:","id","implement","import","importing를","imports는","import는","import로","import를","import하거나","inclusive.\");","input:","interfac","isacceptable(s:","isprim","isprime(2);","isprime(x:","javascript","javascript가","javascript로","javascript에는","javascript에서","join(...paths:","jqueri","jquery.d.t","jquery;","jquery라는","js","larg","left","left:","lettersonlyvalid","lettersonlyvalidator();","lettersonlyvalidator.t","lettersregexp","lettersregexp.test(s);","level","level)","lib\";","lib.d.t","libraries)","list","load","log.t","m","m.someth","mainvalid","match\"","match\"}`);","matches\"","math","mathlib.isprime(2);","mathlib;","memori","mod_1","mod_1)","mod_1.someth","mod_1;","mod_1_1;","modul","module\";","module)","module.export","module.js\";","modules)","multipl","my.application.customer.addform과","my.application.order.addform","myclass.t","myfunc.t","mylargemodul","mylargemodule.dog();","mylargemodule.t","mythings.t","myurl","myvalid","name","names)","namespac","nativ","new","node","node.d.t","node.j","node.js)","node.js에서","node.js의","normalize(p:","num","number","number)","number):","number,","numberregexp","numberregexp.test(s);","objects,","onetwothree.t","onload:","only\"]","only)","operator:","operator;","parse(urlstr:","parseint(s).tostring()","parseintbasedzipcodevalid","parseintbasedzipcodevalidator.t","parsequerystring?,","pathname?:","pattern","possible)","privat","processdigit(digit:","programmercalcul","programmercalculator.digits.indexof(digit);","programmercalculator.digits.length)","programmercalculator.t","programmercalculator.ts를","programmercalculator는","protect","protocol?:","public","put","regexpbasedzipcodevalidator}","regist","requir","require(\"...\")문이","require(\"./mod\");","require(\"./zipcodevalidator\");","require(\"mod\");","require(\"module\")을","require(\"url\");","require()","require([\"./zipcodevalidator\"],","require(modulename:","require(modulenames:","require.j","require.js)","require.js의","require.js입니다.","requirej","return","return;","right:","right;","s","s.length","s;","scenarios)","sep:","setters:[","shorthand","side","simplemodule.j","simplemodule.t","singl","slashesdenotehost?):","somefunc","somefunc()","somefunc();","someth","sometyp","sometype();","sometype,","statements)","static","staticzipcodevalidator.t","step...\"","string","string)","string):","string,","string;","string[],","string]:","strings.foreach(","stringvalid","stringvalidator;","structur","super();","switch","symbol이","system","system.collections의","system.import(\"./zipcodevalidator\").then((zipcodevalidator:","system.js)","system.js의","system.register([\"./mod\"],","system:","systemj","t","t();","t)","t;","test","test(c,","test(c:","test.t","testcalculator.t","testprogrammercalculator.t","things)","this.bas","this.curr","this.current);","this.current;","this.evaluate();","this.evaluateoperator(this.operator,","this.memori","this.memory,","this.memory;","this.oper","this.processdigit(char,","this.processoperator(char);","throw","top","tree","tsc","typeof","typescript","typescript는","typescript로","typescript에","typescript에서는","umd","umd,","undefined)","url","url.parse(\"http://www.typescriptlang.org\");","url;","us","v","v;","valid","validation.t","validator();","validator.isacceptable(s)","validator.zipcodevalidator();","validators)","validators:","validators[\"lett","validators[\"zip","validators[name].isacceptable(s)","validator를","valu","value:","value;","var","variable,","void):","void;","wildcard","within","x","x(y);","x,","y","you'r","z]+$/;","za","zcv","zcv();","zip","zip();","zip)","zipcodevalid","zipcodevalidator();","zipcodevalidator.numberregexp.test(s);","zipcodevalidator.t","zipcodevalidator.zipcodevalidator();","zipcodevalidator:","zipcodevalidator;","{","{y}","{zipcodevalid","{};","{를","}","}\"","})(function","});","};","}],","}`);","}인","가깝게","가능한","가능합니다.default","가이드","가져오고","가져오기","가져오려면","가져올","가져옵니다.","가져와야","가지","가지고","가진","가집니다.","각","간단한","간단히","간의","간접","간주합니다.","감싸고","감지합니다.모듈","값","값을","값의","갖는","같은","같이","개념을","개념이","개의","객체","객체도","객체로","객체를","객체와","객체처럼","검사","것과","것도","것들을","것은","것을","것이","것이라고","것이라면","것입니다.","것입니다.모듈","것입니다.모듈에는","것입니다.앞서","것처럼","결과를","결합될","결합할","경우","경우를","경우에","경우에만","경험을","계산기","계산기로","계산기를","계산기의","계층에","계층을","계층적","고급","고려하세요)","고려하세요.","고려해보세요.또한","고려해야","고통이","공유합니다.","과","과도하게","관계는","관련된","관심이","구문은","구문을","구성하여","구조를","구조화","구조화를","구현을","구현하여","권장되지는","그","그러면","그럴듯한","그룹화할","글로벌","기능을","기반","기본","기존의","기타","끝에","나열","나중에","나타내는","내고","내보내기","내보내기\"가","내보내기(re","내보내기에","내보내는","내보내도록","내보내지","내보내지만","내보낸","내보낼","내부에서","내부에서만","내에서","내용은","너무","넓은","네이밍은","네이티브","네임","네임스페이스","네임스페이스,","네임스페이스가","네임스페이스는","네임스페이스로","네임스페이스를","네임스페이스에","네임스페이스와","노출된","노출합니다.다시","논리적","논리적으로","는","다루기","다른","다수를","다수의","다시","다음과","다음은","다음을","단일","대로","대부분의","대상에","대상을","대신하는","대체하는","대한","대해","더","데","도입하는","도입하지","동일한","동일합니다).","동작을","동적","동적으로","되므로","될","됩니다.","됩니다.참조","두","두고","둘은","들어","들어:","들어보겠습니다","등을","등이","따라","따릅니다.","따옴표","때","때:","때는","때문에","때의","또","또는","또한","라이브러리","라이브러리가","라이브러리는","라이브러리를","라이브러리에는","라이브러리의","라인에","래핑하는","레벨","레벨에","레벨을","레벨의","로더는","로더들은","로더를","로더에","로더에서","로더이며","로드","로드가","로드됩니다.이","로드의","로드하여","로드할","로딩","로딩과","로컬","로컬로","를","마세요","마세요!)","마찬가지로","마찬가지입니다.모듈의","마찰을","마찰이","만들","만큼","많은","많이","맞게","매우","메서드에도","명시적으로","명칭이","명확하고","몇","모델링하기","모두","모듈","모듈\"은","모듈과","모듈로","모듈만","모듈별","모듈에","모듈에는","모듈에서","모듈은","모듈을","모듈의","모듈이","모듈이라고","모든","목록을","목적이","문","문서를","문은","문을","문자열","문자열이","문제가","문제는","및","반대로","반대의","방법에","방법을","방식으로","방출된","방출될","방출하지","배치하세요.","변경되었습니다.\"내부(internal)","변경할","변경합니다","변경해야","변수).이러한","변수,","변수로","변수를","변형시키지","변환되는지","별도의","별칭(alias)","병합되지","보강하는","보강하지","보여줍니다.","보이지","볼","봅시다.","부분적으로","부수","불가능합니다.","불필요합니다.","붙은","블록처럼","비슷한","빠르게","사용","사용되고","사용되는","사용되는지","사용되어야","사용되지","사용된","사용될","사용을","사용자가","사용자들은","사용자를","사용자에게","사용자의","사용하기","사용하도록","사용하려면","사용하며","사용하세요","사용하세요.require.js의","사용하십시오.","사용하여","사용하지","사용하지만","사용한","사용한다.이러한","사용할","사용합니다.","사용합니다:","사용해야합니다.","사항:","상태를","상황에","새로운","새롭게","샘플","샘플:","생각하세요.","생각하지","생각할","생략","생성","생성하며","생성합니다.생성된","선언","선언된","선언만","선언문은","선언으로","선언은","선언을","선언이라고","선언적입니다.","선언해야","선택입니다.타입의","선택적","선택적으로","선택적입니다.","선택하게","선호되는","설계되었거나","설명하려면","설정합니다.이러한","성능이","소개","수","수도","수의","수있는","수준에서","수준의","수행됩니다.각","쉽게","쉽습니다.export","스코프","스코프가","스코프로","스코프에서","스크립트","스페이스","스페이스를","스페이스와","시간을","시나리오","시나리오를","시스템에","시작할","시험용","식별자가","신중히","신호","실제로","실행됩니다.이는","실행하기","실행합니다.javascript에서","싶지","아닌","아닙니다.모듈","아래에서는","아래의","아이디어는","안전성을","않고","않는","않는다는","않는지","않다면","않습니다).","않습니다.","않습니다.typescript는","않습니다.권장되는","않습니다.사용하지","않으려면","않으면","않은","않지만","알려진","애플리케이션의","어노테이션의","어떠한","어떻게","언급했듯이","없거나","없는","없습니다","없습니다.","없습니다.사용자는","없을","엔티티를","여부를","역할을","열거형이","염두에","예를","예입니다.네임스페이스가","예제","예제는","예제를","예제에","오류:","오직","와","외부","외부에","외부에서","요소들입니다.이","용어에","우리의","우연한","워크플로우를","원래","원본","원하는","웹","위의","위치에","위치에서","위치에서만","위한","위해","위해서","위험","유용하므로","유용한","유지하기","유효성","의도가","의미론을","의미합니다.반대로","의존된","의존성을","의해","이","이것들을","이것은","이것을","이는","이동시키세요)","이동할","이들은","이러한","이를","이름","이름으로","이름으로도","이름을","이름이","이름이지만","이미","이상의","이유는","이전","이제","익숙하다면","인터페이스","인터페이스,","인터페이스와","일","일반적으로","일부","일부는","일부로만","일치하는","잃지","입력","입력에","있고","있는","있다는","있습니다","있습니다.","있습니다.(스크립트는","있습니다.c/c++에","있습니다.default","있습니다.typeof","있습니다.typescript에서는","있습니다.그러나","있습니다.목록","있습니다.이를","있습니다.일반적으로","있습니다.컴파일러는","있습니다:","있으며","있으며(이","있을","있지만","자세한","자체","자체적으로","자체적인","작동하는","작동하려면","작성되지","작성될","작성하는","작성하여","작성할","작성해","작업은","작은","잘","재빠르게","저장하는","적어야","적용되는","적재할","적절한","전달하고","전에","전역","전체","절대","점을","접근하기","접근할","접두사","접미사를","정말","정보는","정의되어","정의된","정의를","정의하지","정의할","정적","제거하고","제거하면","제공하는","제공합니다.","제공합니다.반면","조건에서만","조직","조직으로","존재하지","존재합니다.경로와","종종","주요","줄이는","중","중에","중요합니다.예를","중첩","중첩의","증가하지","지원을","지원합니다.","지원합니다.default","지을","지정된","지정됩니다.","지정하려고","지정하지","지정합니다.","지정해야","직접","찍을","참고","참조","참조를","참조하는","참조하세요.","찾고","찾기","찾습니다.","처음","체계가","최상위","최적의","최적화가","최적화되고","추가","추가적인","추가하기","추가하는","추가하여","추가합니다.이는","추가합니다.표현이나","충돌된","충돌은","측면에서","측면에서는","커맨드","커스텀","컨텐츠를","컬렉션","컴파일러는","컴파일시","컴파일하기","컴파일하려면","코드","코드로","코드를","코드에서","클래스","클래스,","클래스에","클래스와","클래스의","키워드는","키워드로","키워드를","키워드와","타입","타입에","타입을","타입의","타입이","태그와","테스트입니다.","테스트입니다.새로운","테스트입니다:","테스트하는","통과했는지","통합했습니다.","통해","통해)","트렌드는","특별한","특정","특정한","파일","파일들을","파일로","파일에","파일을","파일이","파일입니다)","패턴","패턴은","패턴을","패턴의","패턴이","편리합니다.그렇게하기","편리합니다.예를","포함된","포함하는","폴더를","표시됩니다.","표현식으로","필수적으로","필요가","필요한","필요할때도","하기","하나","하나라도","하나로","하나를","하나만","하나의","하는","하며","하면","하므로","하지","하지만","한","할","함수","함수,","함수를","합니다(즉","합니다.","합니다.node.js는","합니다.그러나","합니다.너무","합니다.런타임시","합니다.이러한","합니다.이렇게","합니다.일반적인","해결책은","해결해야","해당","핵심","헬퍼","현재","형식","형식을","형태을","호출됩니다.이는","호출에","호출이","호출할","호환되지","확인하세요.","확장된","확장을","확장이","확장하고","확장하여","확장해야","활용되어","효과에","훌륭한","힘들기"],"pages/Namespaces.html":["\"101\"];","\"98052\",","\"ambient\"으로","\"doe","\"matches\"","\"내부","\"내부(internal)","\"네임스페이스\"로","\"네임스페이스\"입니다.\"외부","\"모듈\"입니다","${","&&","'${","'new","(aliases)","(element:","(excerpt)","(first","(let","(selector:","(simplifi","(split","(valid","(work","(모듈","(예:","(즉",".d.t","//","///","/^[0","/^[a","1.5에","2015의","5","9]+$/;",":","=","===","?","[\"hello\",","[s:","ambient","api를","base","boolean;","class","code\"]","console.log(`\"${","console.log(`'${","const","d3","d3.base;","d3.d.t","d3:","d3는","d3이라는","declar","ecmascript","event","event:","event;","eventtarget):","excerpt)","export","export를","extend","file","file)","files)","implement","import","imports(별칭으로","imports에서","import는","interfac","isacceptable(s:","ismatch","javascript","js","lettersonlyvalid","lettersonlyvalidator();","lettersonlyvalidator.t","lettersregexp","lettersregexp.test(s);","lettersregexp와","libraries)","match\"","modul","multi","mytestpage.html","name","namespac","new","number;","numberregexp","numberregexp.test(s);","numberregexp는","only\"]","outfil","outfile을","polygon","polygons.square();","requir","require(\"name\")를","return","s","s.length","sample.j","select:","selection;","selector","shape","shapes.polygons.square()'와","shapes.polygons;","singl","sq","squar","steps)","string","string)","string):","string]:","strings)","stringvalid","stringvalidator;","test.t","triangl","tsc","typescript","typescript에서","typescript의","valid","validation.lettersonlyvalidator();","validation.lettersonlyvalidator)와","validation.stringvalidator;","validation.t","validation.zipcodevalidator();","validation라는","validators)","validators:","validators[\"lett","validators[\"zip","validators[name].isacceptable(s)","validators[name].isacceptable(s);","validator를","var","var에","x","x:","y:","z]+$/;","za","zipcodevalid","zipcodevalidator();","zipcodevalidator.t","{","{};","}","}\"","}'","}'.`);","};","}`);","가져오는","가져온","가지","각","각각","간","간단한","간단히","간략하게","간의","값의","같이","개별적으로","개의","객체를","객체만","객체에서","객체와의","객체의","걱정하지","걸맞은","걸음","검사기","검사기를","것입니다.이러한","것입니다.전역","것입니다.파일은","것처럼","게시물은","경우","곳이라면","관계를","관련","구성하는","구현","구현을","그","기능을","기반으로","기여할","나누어","나눌","남아있어","내부","네임스페이스","네임스페이스(이전의","네임스페이스는","네임스페이스로","네임스페이스를","네임스페이스에","노출되지","노출하므로","는","다른","다양한","다음과","단순화할","단일","대신","대신)를","대한","대해","대해서도","더","데이터","동일한","동일합니다","동일합니다).","두","들어","들어:","따라","때","때문에","또","또는","라이브러리","라이브러리는","라이브러리로","라이브러리에서","라이브러리의","레벨의","로더","로드되기","로드해야","마무리합시다.","만들려고","많은","많이","맞게","머리말에","먼저","명칭이","몇","모듈","모듈\")를","모듈\"은","모듈을","모든","문자열","문자열이","반영되지","방법은","방법을","방법이","방법입니다.","방지합니다.","방출된","방출할","변경","변경되었습니다.\"내부","변경되지","변수","변수에","별개의","별개이지만","별칭","보려면","보수하기","보여","보이지","볼","분할","불림)를","붙입니다.반대로","비슷하지만","사용과","사용되는","사용된","사용자","사용자에게","사용하여","사용하지","사용할","사용합니다.","사항:","사항은","사항이므로","살펴보겠습니다.","상태로","새로운","샘플","생각할","생성되면","생성된","생성하는","선언에","선언을","선언할","선언해야","선호되는","설명하려면","설명합니다.용어에","세부","소개","수","수도","수있는","순서대로","쉽게","시작해보겠습니다.웹","시험용","식별자에","심볼과","심볼에","심볼의","아래쪽에","않는","않습니다.","않습니다.파일의","않은","않을","알려주는","애플리케이션이","앨리어싱된","양식에","어디에서나","언급됩니다.또","언급할","엔티티를","여기서","여러","여부를","예를","예제로","예제에서는","오버로드함으로써","와","외부에서","외부의","용어로","용어에","원래","원하기","원할","웹","위해","유지","유효성","의미에","의존성이","이","이동합니다.여기서","이들은","이름","이름을","이름의","이제","익숙하다면","인기","인터페이스와","일반적으로","일종의","입력","입력을","있기","있기를","있는","있습니다.","있습니다.c/c++에","있습니다.만약","있습니다.몇","있습니다.비슷한","있습니다.파일","있습니다:","있으며","자동으로","작성되지","작성할","작성했습니다.","작업에는","작업을","작업하기","작용합니다.중요한","적절한","전역","점은,","정렬합니다.각","정의되어","정의된","정의하지","정의합니다.typescript","정의합니다.이","제공하는","조직","종류의","좋은","주는","줍니다.","증가함에","지정할","직접","짧은","참고","참조","참조이므로","첫","체계를","최상위","추가하는","추가함에","추가합니다.테스트","추적하고","출력","충돌에","컴파일","컴파일(기본값)을","컴파일된","컴파일러가","컴파일러는","컴파일러에게","코드는","코드를","코드에는","코드에서","클래스를","키워드가","키워드는","키워드를","타입과","타입을","타입의","태그","태그를","테스트","통과했는지","통해","파일","파일들","파일들로","파일로","파일별","파일에","파일을","파일의","파일이","페이지에","페이지의","포함되면","포함한","표시하는","표현할","프로그램에서부터","하나씩","한곳에서","할","할당합니다.이것은","합니다.","합니다.대부분의","합니다.이","현재","형식을","형태을","호출합니다.일반적으로","혼동을","확인하거나","확인하기","확인해야"],"pages/Namespaces and Modules.html":["\"...\";에서","\"./shapes\";","\"somemodule\"","\"somemodule\";","\"네임스페이스\"입니다.\"외부","\"모듈\"입니다","'...',import","(needless","(pitfal","(trade","(use","(예:","(즉","*","*/","...",".d.t",".t",".ts,",".tsx","/*","//","///","1.5에","1.8","2015","2015의","=","ambient","amd","class","commonj","commonjs/require.js)작은","declar","ecmascript","export","fn():","function","html","import","import(예:'...'에서","ing","javascript","js","m","modul","modules)","mymodules.d.t","myothermodule.t","namespac","namespaces)","namespacing)","namespacing은","new","node.d.t","node.j","off","outfil","outfile을","require(\"...\");","shape","shapeconsumer.t","shapes.shapes.triangle();","shapes.shapes?","shapes.t","shapes.triangle();","shapes은","squar","square를","string;","system을","t","triangl","triangle과","typescript","typescript는","typescript에서","typescript의","umd를","x","{","}","가져오는","가지","가지고","가진","간단한","간단히","간에","감싸고","감쌀","강력한","같은","개의","객체로","객체에","걸쳐있을","겁니다.특정","것과","것을","것이다.차이점을","것입니다.","것입니다.모듈","것입니다.모듈의","것입니다.예를","게시물은","격리","결정하기","경로로","경로를","경우","경우는","경우에는","계층을","고급","관계","관리에","구성","구성하는","구조로","구조의","구조화하기","구조화하는","구현에서","권장","그룹을","그룹이며","그리고.d.ts를","기반으로","기본","기본이며","기억해야","끝날","나은","내보낸","내용은","내용의","네임","네임스페이스","네임스페이스는","네임스페이스를","네임스페이스에서","네임스페이스와","네임스페이스의","논리적","는","다룰","다른","다수의","다양한","다음과","다음은","대규모","대상","대상으로","대신","대응을","대응이","대한","대해","더","데","도구","동안","동일한","동일합니다).","된","될","됩니다.","두","들어","따라","따른","때","때문에","또는","또한","로더에","마찬가지로","마찬가지로,","만듭니다.여러","맞게","매우","먼저","메커니즘의","명칭이","몇","모두","모듈","모듈\"은","모듈로","모듈성","모듈에","모듈에는","모듈은","모듈을","모듈의","모듈이","모듈인","모든","문서를","문을","및","반복해서","발생하는","방법에","방법을","방법이","방법임을","방법입니다.","방지하는","방출된","번들링을","변경되었습니다.\"내부","변환하는","부터는","불립니다.네임스페이스를","불필요한","사용되는","사용자가","사용자들을","사용하기","사용하는","사용하여","사용할","사이에","사전에","사항:","사항이","살펴보고","새로운","샘플에서","서로","선언","선언을","선언한다는","선언해야","선호되는","설명하고","설명하기","설명합니다.또한","성가시게","섹션에서는","소개","소스","수","수도","수정된","쉽게","스코프에","스페이스와","시스템에","식별하기","실수는","심볼을","아닌","아닐","아무런","않는다는","않아야","알아보겠습니다.","애플리케이션에서","애플리케이션에서는","애플리케이션의","어려울","언어의","없다는","없습니다.","없습니다.이는","없으면","없지만","엔진","여기","여기서","여러","연결될","연결할","예입니다.","예정입니다.","오염과","옵션을","와","요소","요소이며","용어에","우선","웹","위한","위해","위해서는,","위험","위험에","유의해야","유지","의존성을","의해","이","이를","이름","이름은","이름을","이상에서는","이유가","이유를","이점이","이제","이해하기","이해할","일대일","일반적인","있게","있는","있습니다","있습니다.","있습니다.네임스페이스는","있습니다.모듈은","있습니다:","있으며","있지만","자세한","자체는","장기적인","재사용,","적절한","전역","정보를","정의되기","제공하고","제공하지","제공합니다.","좋은","주요","주제를","지원을","지원해야","지정하지","지정할","차이점은","참고","참조","참조하기","참조하세요.","참조하세요.네임스페이스에","찾는","찾습니다.이","찾으려","찾을","최상위","최적이","추가적인","충돌을","컴파일러가","컴파일러는","코드","코드를","코드에","코드와","큰","타입","태그는","태그로","특징은","특히","파일","파일:","파일과","파일들을","파일로","파일에","파일을","파일이","페이지에","포","포함시킵니다.가장","포함하는","프로그램을","프로젝트의","피하는","필요가","하는","한가지","한다는","할","할당할","함정을","합니다.","합니다.따라서","합니다.이에","합니다:","해줍니다.이것은","향상된","현재","호환","혼란스럽고","효과는","흔히"],"pages/Module Resolution.html":["\"*\"(모든","\"*\",","\"*\":","\".\",","\".\"보다","\"../constants/http\";","\"../node_modules/jquery/dist/jquery\"에","\"./components/entry\";","\"./moduleb\"를","\"./moduleb\"와","\"./src\"를","\"./template\"로","\"/mod\";","\"@angular/core\";","\"baseurl\":","\"baseurl\"과","\"baseurl\"에","\"compileroptions\":","\"generated\"가","\"generated/*\"","\"generated/templates/views\"","\"jquery\":","\"jquery\";","\"jquery\"에","\"lib/mainmodule.js\"","\"main\"","\"main\":","\"main\"의","\"modulea\"","\"modulea\"와","\"modulea의","\"moduleb\"","\"moduleb\"는","\"moduleb\"를","\"moduleb\"와","\"node_modules/jquery/dist/jquery.slim.min.js\"로","\"paths\"","\"paths\":","\"paths\"가","\"paths\"는","\"paths\"를","\"rootdirs\":","\"rootdirs\"를","\"src/#{locale}\"","\"src/de\",","\"src/views\",","\"src/zh\",","\"typescript\"와","\"很高兴认识你\"","\"您好吗\",","\"가상\"","\"메인\"","\"배포\"되는","\"추가\"하지","\"프로젝트\"로","#{locale}을","$","'*'","'./#{locale}/messages'에서","'./lib/typescript.d.ts'","'./lib/typescript.d.ts'가","'./template1')","'./view2')","'./zh/messages'의","'folder1/file2'","'folder2/file3'","'folder2/file3')","'generated/*'","'modulea'가","'modulea'을","'moduleb'","'node_modules'","'node_modules/typescript.d.ts'","'node_modules/typescript.ts'","'node_modules/typescript.tsx'","'node_modules/typescript/lib/typescript.d.ts'","'node_modules/typescript/lib/typescript.d.ts'.","'node_modules/typescript/lib/typescript.d.ts'를","'node_modules/typescript/lib/typescript.d.ts'에서","'node_modules/typescript/package.json'.","'nodejs'","'nodejs'.","'package.json'","'package.json'에는","'src/app.ts'.","'src/node_modules/typescript.d.ts'","'src/node_modules/typescript.ts'","'src/node_modules/typescript.tsx'","'src/node_modules/typescript/package.json'","'tsconfig.json'의","'types'","'typescript'","'typescript'는","(\"main\"","(\"types\"","(.ts,","(15)에서","(4)와","(7)에서","(8)과","(addit","(classic)","(common","(how","(import","(modul","(node)","(path","(rel","(thing","(trace","(use","(virtual","(whi","(주어진","*","../","./","./#{locale}/messages를","./#{locale}/messages와","./de/messag","./zh/messages,","./zh/messages에는",".d.t",".d.ts)을",".js로",".t",".ts/.tsx",".tsx,","/,","//","///","/generated/templates/views에","/generated/을","/moduleb.d.t","/moduleb.t","/node_modules/moduleb.d.t","/node_modules/moduleb.j","/node_modules/moduleb.t","/node_modules/moduleb.tsx","/node_modules/moduleb/index.d.t","/node_modules/moduleb/index.j","/node_modules/moduleb/index.t","/node_modules/moduleb/index.tsx","/node_modules/moduleb/package.json","/root/moduleb.d.t","/root/moduleb.t","/root/node_modules/moduleb.d.t","/root/node_modules/moduleb.j","/root/node_modules/moduleb.t","/root/node_modules/moduleb.tsx","/root/node_modules/moduleb/index.d.t","/root/node_modules/moduleb/index.j","/root/node_modules/moduleb/index.t","/root/node_modules/moduleb/index.tsx","/root/node_modules/moduleb/package.json","/root/src/folder/a.ts에","/root/src/folder/moduleb.d.t","/root/src/folder/moduleb.t","/root/src/modulea.js가","/root/src/modulea.js에","/root/src/modulea.ts에서","/root/src/moduleb","/root/src/moduleb.d.t","/root/src/moduleb.js라는","/root/src/moduleb.t","/root/src/moduleb.tsx","/root/src/moduleb/index.d.t","/root/src/moduleb/index.t","/root/src/moduleb/index.tsx","/root/src/moduleb/lib/mainmodule.js를","/root/src/moduleb/package.json","/root/src/node_modules/moduleb.d.t","/root/src/node_modules/moduleb.j","/root/src/node_modules/moduleb.t","/root/src/node_modules/moduleb.tsx","/root/src/node_modules/moduleb/index.d.t","/root/src/node_modules/moduleb/index.j","/root/src/node_modules/moduleb/index.t","/root/src/node_modules/moduleb/index.tsx","/root/src/node_modules/moduleb/package.json","/src/view","/을",":","=","========","=>",">","[","[\"node_modules/jquery/dist/jquery\"]","]","];","`types\"","ambient","amd","app.t","app.ts를","a의","b","back","base","baseurl","baseurl에","baseurl을","compiler?)","compon","declarations으로","declaration에","declaration을","default","defaulthead","directori","entri","es2015인","exclud","exist","exist.","export","fall","field","file","file1.t","file2.t","file3.t","flags)","folder.","folder1","folder1/file2","folder2","folder2/file3","for)","found","gener","generated/folder2/file3","import","imports)","imports는","imports를","imports에","imports의","import가","import는","import된","import를","import에서는","import의","import합니다.","index.j","index.js라는","jquery는","jquery에","kind","list","load","look","mapping)","messag","modul","modulea.t","modulea는","modulea를","moduleb.j","moduleb가","moduleb를","moduleresolution를","modules)","name","name의","node.j","node.js가","node.js는","node.js보다","node.js의","node_modules라는","node_modules를","node_modules에서","node는","non","noresolv","noresolve)","noresolve를","npm","out","package.json","package.json에","pick","projectroot","projectroot/folder1/file2.ts.","projectroot/folder2/file3.ts.","projectroot/generated/folder2/file3.ts.","questions)","refer","rel","relative로","require(\"./moduleb\");","require(\"moduleb\");","requirej","require라는","require에","resolut","resolution)","resolution은","resolv","result.","root","rootdir","rootdirs)","rootdirs를","rootdirs의","roots를","specified,","src","src/views의","still","strategies)","successfulli","system","systemj","templat","template1.t","traceresolut","traceresolution을","ts","ts2307","tsc","tsconfig.json","tsconfig.json는","tsconfig.json은","tsconfig.json을","tsconfig.json의","tsconfig.json파일에서","tsconfig.json파일은","typescript","typescript.d.t","typescript는","typescript의","ui컨트롤의","ui템플릿","up","url","us","var","view","view1.t","view2.t","vs.","x","{","|","}","}를","“exclude”를","“files”","“files”을","│","└──","└───lib","└───src","└───typescript","├──","├───node_modul","가능한","가상","가정됩니다.","가정합니다.예를","가정해","가져","가져오기","가져오기를","가져오지","가져온","가져올","가지","가지고","가진","각","간단하게","간단합니다.예를","간주됩니다.몇","간주합니다.그","값","값)","값으로","값은","값을","같습니다:","같은","같을","같이","개발할","거슬러","검사하기","검사해야","검색한","검색합니다.","검색합니다.node_modul","겁먹지마세요","것과","것들이","것으로","것은","것을","것이","것입니다.","것입니다.다음에","것입니다.또는","것처럼","결과","결과가","결과는","결과와","결정됩니다:","결합되어","결합하세요","경로","경로가","경로는","경로를","경로와","경로의","경로인","경로인지","경로인지에","경우","경우(\"modulea\"의","경우가","경우에는","경우에는)","계산)","계획을","고려하세요.","고려해보세요.","고려해보세요.빌드","곳에","공통","관계","관계를","관련이","관련하여","구성됩니다.","구성을","구성하는","구조를","국제화","그","그것의","그것이","그래도","그러나","그런","그렇지","기능을","기대할","기록합니다.이","기반으로","기본","기본값은","기준","나머지는","나옵니다:","나중에","나타내는","내보낸다고","내용은","내용이","노드","노드.이","노드와","노드의","노드입니다.","노력합니다:","논리적으로","다룰","다르게","다른","다를","다음","다음,","다음과","다음이","단계","단계는","단계를","단계에서","단계의","단일","달라집니다.","달성하기","대상으로","대신","대신에","대체","대체를","대한","대해","더","덮어씌웁니다.typescript는","도구가","도구는","동일한","동작은","됩니다:","두","두가지가","두번째","들릴지","들어","들어,","들어:","등으로","디렉토리","디렉토리가","디렉토리내의","디렉토리를","디렉토리부터","디렉토리에","디렉토리의","디렉토리일때마다","따라","따라,","따라서","따르고","따르는","따르면,","따른","따릅니다:","때","때까지","때는","때때로","때마다","때문에","또는","또한","라인","런타임","런타임시에","런타임에","레벨","레벨이거나","레이아웃은","레이아웃이","로","로더","로더를","로드","로드하는","로직","로직에","로직을","로케일을","를","마지막으로","마찬가지로","만드는","만듭니다.“exclude”","매우","매핑","매핑되어야합니다.","매핑은","매핑을","매핑의","매핑하세요.","매핑합니다.","먼저","메시지를","메커니즘을","몇","모두","모듈","모듈과","모듈로","모듈만","모듈에","모듈은","모듈을","모듈의","모듈이","모든","모르지만","모방하려고","모방합니다.이를","모일","목록","목록에","목록을","목적을","못하는","못하면","무엇을","무엇입니까?","무엇입니까?\"라고","문서를","문서에","문서에서","문서와","문은","문을","문자열을","문제","묻습니다.이것은","물리적","및","바인딩","반영하기","받지","발생한","발생할","발생합니다:","방문할","방법","방법에","방법입니다.이러한","방식으로","배열은","버전과의","번","번들","번들을","변경되지","변경해야합니다.가령","변환됩니다.로더는","변환을","변환의","별","병합된","병합될","보고","보여야","보장되는","복사하는","복사합니다.런타임에","복잡하지","볼","봅시다.app.ts는","분석","불러오기","붙은","뷰는","비","비례해서","비상대적인","빌드","빌드의","사용을","사용자","사용자의","사용하기","사용하는","사용하면","사용하세요.","사용하세요.\"rootdirs\"은","사용하세요.만일","사용하여","사용할","사용합니다","사용합니다:","사용해야","살펴보겠습니다.node.js는","살펴봅니다:","삽입하여","상관없이","상대","상대적","상대적으로","상대적인","상대적인지","상대적입니다.","상위","샘플","생각해보세요.","생성기에","생성된","생성하기","생성하는","생성합니다.여기에는","서로","선언하는","선택하는","설명되어","설명을","설명하는","설명한","설정에서","설정하면","설정할","성공적으로","세이프","섹션에서는","소스","소스가","소스는","소스에","수","수는","수도","수에","수의","수행됩니다.node.js가","수행됩니다.node는","순서로","스크립트에","시","시간","시나리오를","시도하게됩니다:","시도하세요:","시도할","시도합니다.","시도합니다.전체","시도합니다.파일에","시작하기","시작하는","시작하여","식별하는","실행하면","싶다면","아닌지에","아닙니다.제공된","아래에","안내합니다.","안전하게","않고","않는","않다면","않더라도","않도록","않습니다.","않습니다.예를","않습니다.컴파일러가","않았기","않았습니다.","않으며","않으면","않은","않을","알고리즘은","알려","알려줌으로써","알려줍니다.","알려줍니다.비","알리기","알릴","알아야","암시적으로","앞에서","애플리케이션이","어디에서","어려울","어플리케이션에서의","얻을","없는","없습니다.","없습니다.상대적인","없이","여겨집니다.","여러","여러개의","여부에","여전히","열거하고","영향을","옆에","예는","예를","예상되는","예에","예에서,","예제를","예제에서","예제입니다.","오기를","오류","오류.","오류:","오류는","오류를","올라갑니다.","옵션은","와","와서","와일드","외부의","우리의","원본","원하는","위에","위의","위치","위치를","위치에","위치에서","위치에서는","위치의","위치하지","위한","위해","위해서는","유연성은","유지할","으로","의미하기때문에","의미하는지","의존성을","의존하는","의해","이","이것은","이동하세요.","이동했음을","이때","이러한","이를","이름","이름과","이름을","이름의","이름이","이름입니다","이번","이에","이유는","이유를","이전","이제","이해하려면","인수의","일","일련의","일반적으로","일반적인","일부","일부로","일부로써","일에","일치하고","일치하는","일치하지","임의","임포트입니다.몇","있고","있는","있는지","있다고","있다는","있다면","있도록","있습니다.","있습니다.node는","있습니다.따라서","있습니다.또한","있습니다.모듈이","있습니다.외부의","있습니다.이것은","있습니다.이를","있습니다.일반적으로","있습니다.지정하지","있습니다.한","있습니다:","있으므로","있지만","자동","자동으로","자세한","자신의","작동하지","작동할","잘못된","적용","적절하게","전달되었습니다.","전달되지","전달된대로","전략","전략에는","전략은","전략을","전략이","전략이었습니다.요즘은","전에","전제로합니다.","전체","점프합니다.이것은","접두어","정교한","정말로","정보를","정의","정의될","정의로","정의를","정의인","정확히","제공하기","제외","제외되었는지","제외하려면","제외해야","조건부","조회를","존재","존재하기를","존재하지","존재할","존재합니다.","좀","종류가","좋아요,","좋아요.","주로","주목하는","주목하세요.","주의사항","주의하십시오.\"baseurl\"을","주의해야합니다.","줌으로써","중","중에","중요합니다.이","중요합니다.전통적으로,","즉","지시자가","지시합니다.모듈을","지식을","지역","지역에","지원","지원되는","지원합니다.다음은","지정)","지정되지","지정된","지정에","지정하고","지정하는","지정하려면","지정하지","지정할","지정합니다.따라서","지정합니다.이","지정해야합니다.","직접","진단하거나","질문","집합에","집합에서","참조가","참조하는","참조하는지","참조하세요.","참조할","참조합니다.","찾게","찾기","찾습니다.","찾습니다.따라서","찾습니다.이렇게하기","찾아","찾아보게","찾으려고","찾으려합니다.","찾으면","찾은","찾을","찾지","처리됩니다.","처리할","체인에서","체인을","최종","추가된","추가적인","추가합니다.","추상화된","추적","추적을","출력","출력을","출력의","취하는","카드가","캡처할","캡처합니다.","커맨드라인에서","커멘드","컴파일","컴파일러","컴파일러가","컴파일러는","컴파일러에","컴파일러에게","컴파일러에는","컴파일에","컴파일에서","컴파일하는","컴파일하면","코드가","코드입니다.generated/templ","코드입니다.빌드","클래식","클래식.","클래식이며","타임에","타입","템플릿","템플릿이","토큰","통찰력을","통해","트리를","특별한","특수","특정","파악하기","파일","파일과","파일들","파일들에","파일로","파일에","파일에서","파일은","파일을","파일이","패키지에서","패턴과","패턴이","포함","포함되어","포함되지","포함된","포함될","포함됩니다.","포함됩니다.일부","포함됩니다.최종적으로","포함입니다.위에서","포함하는","포함하지","포함한","포함할","폴더","폴더는","폴더로","폴더를","폴더에","폴더에서","폴더의","프로세스","프로세스를","프로세스에","프로세스입니다.import","프로젝트","프로퍼티","프로퍼티를","플러그인과","필드를","필드인","필요가","하게","하나","하나로","하나를","하나에서","하나의","하는","하며","하위","하지","하지만","한","한정되는","할","함께","함수를","합니다.","합니다:","항목에서","항목을","항상","해결할","해당","해석","해석되었습니다.","해석되었으며","해석되지","해석된","해석된다는","해석될","해석됩니다.그러므로","해석은","해석을","해석이","해석하기위해","해석하는","해석하려고","해석하지","해석할","해석합니다:","해치지","현재","현재의","형태가","호출하기","호출함으로써","호환성을","확인","확인되므로","확장자","활성화하면","활용하여"],"pages/Declaration Merging.html":["\"\";","\"./map\";","\"./observable\"","\"./observable\";","\";","\"canvas\"):","\"cyan\")","\"div\"):","\"hello,","\"magenta\")","\"span\"):","\"white\")","\"yellow\")","\"선언","'네임스페이스","'선언","()","(basic","(colornam","(disallow","(f)","(global","(merg","(modul","(x:","(병합되지","+","...","//","1,","10};","2,","4","5,","6,",":","=","==","=>","album","album.albumlabel;","albumlabel","alert(buildlabel(\"sam","anim","animal):","animal;","animalshavemuscl","animalshavemuscles()","animals의","any):","array","array.prototype.toobserv","augmentation)","a를","a와","blue","box","box:","buildlabel","buildlabel(name:","buildlabel.prefix","buildlabel.suffix;","cat):","cat;","class","classes)","classes,","clone(animal:","cloner","color","color.blue;","color.green","color.green;","color.r","concepts)","consumer.t","createelement(tagname:","declar","doanimalshavemuscles()","document","document의","dog","dog):","dog;","element;","enum","enums)","export","exported)","exported되지","function","functions,","global","green","havemuscl","havemuscles;","havemuscles가","height:","htmlcanvaselement;","htmldivelement;","htmlelement;","htmlspanelement;","import","import/export의","interfac","interfaces)","javascript","javascript를","javascript에서","javascript의","label:","leg","map(f:","map.j","map.t","merges)","mixcolor(colorname:","mixin","modul","name","namespac","namespaces)","number;","numberoflegs:","o.map(x","o:","observ","observable.j","observable.prototype.map","observable.prototype.map에","observable.t","observable.ts는","observable;","prefix","red","return","safe)","scale:","sheep):","sheep;","signatures)입니다.시그니처의","smith\"));","string","string)","string):","suffix","t)","toobservable():","true;","typescript에서","typescript에서는","typescript에서도","typescript에서의","typescript의","u):","width:","x","x.tofixed());","zebra","{","{height:","}","가능할","가시성","가장","가져온","가져와","가져와서","가지","가집니다.","각","간주합니다.또한","값","값네임스페이스","값을","같습니다.","같습니다:","같으므로","같은","개념","개념에","개념을","개념이","개의","객체를","객체의","것과","것으로","것은","것을","것이","것입니다.또한","것처럼","결과는","결합합니다.","경우","경우에는","고급","고유한","고유해야","공유하는","관리되는","구현되지","구현은","규칙에","규칙은","그대로","그룹","그룹의","그리고","기계적으로","기능을","기능이","기본","기본적인","기존","나중에","남겨놨습니다","내보내지","내보낸","내보낼","내부","내부(inner)","내부에","내부에서","내용은","내용을","네임","네임스페이스","네임스페이스,","네임스페이스는","네임스페이스를","네임스페이스에","네임스페이스에서만","네임스페이스의","높다는","다른","다음","다음과","다음에","단순하고","단일","단지","대한","대해","더","데","도움이","독립된","동일하게","동일한","되는","되지","됩니다.","두","두개의","들어","따라야","때","때문에","또","또는","레벨","레벨에서","리터럴","리터럴의","마찬가지로","마치","만듭니다.","만하면","많은","매개","맨","먼저","멤버가","멤버는","멤버를","멤버에","멤버의","명확하게","모델링","모델은","모두","모듈","모듈은","모듈을","모방하는","목록의","목적인","못합니다.이런","무슨","문을","문자열","및","바인딩","발생시킵니다.","발생한","방법에","방법으로","방법을","버블링됩니다.","번째","변수","변수가","변수와","별칭","병합","병합\"은","병합'","병합'이라는","병합되는","병합되는지","병합되며","병합되어","병합되지","병합된","병합됩니다.","병합됩니다.그러나","병합됩니다:","병합은","병합을","병합이","병합입니다.가장","병합하기","병합하는","병합하려면","병합할","병합합니다.네임","보려면","볼","불구하고","비","사용자에게","사용하여","사용할","사용합니다.","사이트에","사항을","살펴봅시다:","새로운","새롭게","생성","생성된","생성하기","생성한","생성합니다.타입","생성합니다:","선언","선언과도","선언된","선언에","선언에는","선언에서","선언으로","선언은","선언을","선언의","선언이","선언이든","선언하는","선언합니다:","설명된","설명하는","설명합니다.특히","세","섹션에","섹션을","소개","수","수는","수도","수의","수준에서","수행할","숙제","숙제로","순서를","스코프","스페이스","스페이스가","스페이스는","스페이스도","스페이스를","스페이스에서만","스페이스와","스페이스의","시그니처(special","심볼을","아닌)인","아마도","아티클의","안전한(type","않고","않는","않다면","않습니다.","않습니다.현재","않았기","않은","않은(non","않은)","않음).즉","않지만","알릴","알지","어떻게","언어를","업데이트할","없는","없습니다.","없습니다.클래스","엔티티를","여전히","열거형","열거형을","열어줍니다.","예로는","예를","예에서는","예외는","예제를","예제에서","오류를","오버로드","오버로드가","오버로드를","외에도","요소는","우선순위가","원래","원본과","위로","위해","유니온이","유연합니다.이렇게","유용한","유지됩니다.","유지하지만","의미합니다.이","이","이것은","이것을","이는","이러한","이름에","이름으로","이름은","이름의","이름이","이름이지만","이미","이상의","이점을","이해하는","이해하면","이해할","이해해야","익숙할","인터페이스","인터페이스가","인터페이스보다","인터페이스에","인터페이스와","인터페이스의","일반적인","일부","일부는","일부임에도","일어나는지","일이","있는","있습니다","있습니다(병합되지","있습니다.","있습니다.doanimalshavemuscl","있습니다.observ","있습니다.typescript는","있습니다.내보낼","있습니다.어떠한","있습니다.이","있습니다.즉","있습니다:","자세한","자체가","자체는","작동","작동하지만","작성합니다.마지막으로,","잘","전역","점","점이","접근하는","정도로","정의","정의가","정의로","정의에는","정의하기","정적","제공할","제공합니다.","제한","제한되지","주목됩니다.","주어진","중","지원하지","지정된","지정자와","참조하세요.","참조하세요.확대되는","첫","최상위","추가하여","추가할","추상화","출력된","출발점이지만","컴파일러가","컴파일러는","컴파일러에","클래스","클래스,","클래스는","클래스를","클래스에","클래스와","클래스입니다.네임스페이스를","타입","타입(예","타입을","타입의","타입이","타입이어야","통합이","특수한","파일에","패치","패턴","패턴과","포함된","포함하는","표기법을","표시되고","프로그래밍","프로퍼티가","프로퍼티를","필요가","하나","하나의","하려면","한가지","할","함께","함수","함수는","함수를","함수만","함수에","함수의","합니다.","합니다.결과","합니다.고유하지","합니다.최종","합니다.컴파일러는","해당","해석됩니다.자세한","해야","허용되지","형성합니다.","형태로","형태를","확대","확대는","확대를","확대에서","확대와","확장하는","확장할","확장합니다.","후에","후에는","후위의"],"pages/JSX.html":["\"./mycomponent\";","\"bar\"","\"bar\"].map(funct","\"bar\"].map(i","'foo'에","'mycomponent'의","'some","'{bar?:","'{foo?:","(","()","(attribut","(children","(class","(embed","(i)","(intrins","(prop:","(props)","(react","(react.createelement(\"div\"))로","(react.createelement(mycomponent))가","(sfc)","(the","(type","(valu","({","(예","(예:",")","*속성)가","+","...",".j",".jsx",".tsx",".ts와","/","//","///","1000}","2.3","2})}","2};",":data",";","=","=>","[elemname:","anothercomponent(prop:","any;","any로","as.위","babel)에서","badprop","bar","bar;","bar?:","bar의","base","boolean","boolean}'입니다.","button","catch","checking)","children:","class","clickableprop","color:","compon","component)","componentfoo(prop:","const","context:","customcomp","declar","div","dom","elementattributesproperti","elementchildrenattribut","elementclass","elements)","es6","expression...\"","expressions)","expr은","expr입니다.따라서","extend","foo","foo:","foo;","foo?:","fooprop","fooprop)","foo라고","function","hello","home:","homeprop","homeprops):","import","indexer를","integration)","interfac","intrinsicel","javascript","javascript로","javascript에","js","jsx","jsx.element","jsx.element;","jsx.element[]","jsx.elementattributesproperty에","jsx.elementchildrenattribute를","jsx.elementclass는","jsx.elementclass에","jsx.element에","jsx.element의","jsx.intrinsicel","jsx.intrinsicelements라는","jsx.intrinsicelements에서","jsx는","jsx를","jsx에서","jsx의","mainbutton(prop:","mycompon","mycomponent();","mycomponent가","myfactoryfunction()","myfactoryfunction();","name:","namespac","nativ","native.이","new","notavalidcompon","notavalidfactoryfunction()","number","number;","operator)","optionalprop?:","preserv","preserve,","preserve와","prop","prop'","props.children","props:","props;","propstyp","r.로","react","react,","react.compon","react.createelement(\"div\")","react.createelement를","react를","react에서","react와","react의","render()","render:","requiredprop:","requiredprop이","result","return","sfc는","sfc로","side:","sideprop","sideprops):","span)","string","string;","string]:","string}'입니다","string});","string},","string의","this.props.children","tsconfig.json","type","type)","typescript는","typescript에는","typings에서","typings은","typings을","typings의","unknown","unknownprop이","var","void","world","x:","xml","y:","{","{\"thi","{[\"foo\",","{i","{name:","{this.props.foo}","{value:","{}","{};","{}이지만","|","}","})","})}","})로","};","가능합니다.의미는","가지","가지가","가지를","간단히","간에","간주되지","감싸고","값","값의","강제합니다.","갖습니다.","갖습니다.react","같습니다:","같은","같이","같지만","객체인","거칠","검사","검사는","검사를","검사에는","검사에서","것과","것들을","것을","것입니다.","것입니다.만일","것입니다.이것은","결과","결정된","결정됩니다.다시","결정됩니다.단일","결정됩니다.사용할","결정하는","결정합니다.jsx.elementchildrenattribute는","경우","경우,","계속","괄호","괄호를","구문","구문이","구분하기","구분할","구성","구조","구현에","그","그렇지","그리고","기능","기반","기본","기본적으로","꺾쇠","나눌","내부","내장","내장된","네임스페이스를","는","는jsx.intrinsicelements에","다르게","다르지만","다른","다시","다음","다음과","단계","단계는","단계에만","단순히","단언","단언을","단일","대문자","대문자로","대신","대한","더","덮어쓰게","데","도입해야","도입했습니다.하위(children)는","동작하지만","동작합니다.","되고","될","됩니다.","두","들어:","따라","때","때문에","때문입니다.","때문입니다.기본적으로","또는","똑같이","라인의","리액트","마찬가지로","맞는","먼저","명령","명시적으로","몇가지","모두에서","모드","모드가","모드는","모든","못한다면","무상태","문자열","문자열을","문자열이어야","미칩니다","및","반면","반면에","반환","반환되는","발생하기","발생합니다.","방법","방법에는","방법을","방출","방출되는","방출하고","배열이","버전에서","번","번째","변수","변형되어야","변환","변환을","보고합니다.","보여야합니다.내장","복잡합니다.이전에","본질적으로","볼","분류됩니다.jsx.element","블랙박스","사용","사용되도록","사용됩니다.","사용됩니다.선택적","사용을","사용자","사용하기","사용하기에","사용하려면","사용하여","사용할","사용합니다.","사용합니다.내장","사용해야","사이에","사이의","삽입할","새로운","생성한","선언에","선언해야","선언해야합니다.","설정되면","성공하면","세","소개","소문자로","속성","속성과","속성은","속성을","속성의","손실을","수","수도","숫자로","쉽게","스코프에","스타일과","시그니처","시그니처과","시그니처의","시작하고","시작합니다.","식별자","식별자가","식별자는","식별자로","실패한다면","아니기","아닌","아닙니다.","않는다면","않습니다.","않습니다.preserv","않습니다.다만","않았기","않으면","않을","알","알려져야","애플리케이션도","약간의","어려움이","얻었으나","없기","없습니다","없습니다.이것은","없으며","없으면","없으므로","에","여기서","여기서도","연산자","연산자가","연산자는","연산자도","연산자로","영향받지","영향을","예를","예제는","예제에서","예제의","오류","오류,","오류:","오류가","오류로","오류를","오버로드","오버로드를","옵션을","요소","요소,","요소는","요소를","요소에","요소에서","요소와","요소의","원래","원할","위","위의","위해","위해서는","유니온에","유지하고","유지합니다.추가적으로","유효한","은","의해","이","이것이","이러한","이를","이름에서","이름은","이름을","이름이","이유가","이유는","이해하기","이해해야","이후","인기를","인수가","인스턴스","인터페이스가","인터페이스를","인터페이스에","인터페이스에서","인터페이스의","일단","일부로","입니다.","입니다.jsx.elementattributesproperty를","입력","있게합니다.","있는","있다는","있도록","있듯이","있습니다","있습니다.","있습니다.react","있습니다.typescript는","있습니다.typescript도","있습니다.결과적으로","있습니다.그러나","있습니다.이렇게","있습니다.하지만","있습니다:","있으며","있으므로","자체","작동합니다:","작성","작성한","작성할","작업을","잘","적절하게","적절한","적합하도록","전개","전달되는","전에","점에서","정보를","정의","정의됩니다.반환","정의하는","정의합니다.","제한하도록","제한할","조금","조회됩니다.","존재하는","존재하지","좋아요","좋아요,","주어지면","주어진","주의사항:","주장하고","중괄호","중요한","지원됩니다.","지원합니다.","지정되어","지정되지","지정하기를","지정하세요","지정하여","지정하지","지정할","지정합니다","직접","집합을","차이가","차이를","참고:","참조됩니다.","참조할","찾을","채우기","첫","추가되었습니다:","출력","출력에는","출력은","출력의","커맨드","컨벤션을","컴파일할","컴포넌트","컴포넌트(stateless","컴포넌트는","컴포넌트로","컴포넌트의","코드는","코딩되어","클래스","클래스가","클래스라면","클래스의","타입","타입과","타입에","타입에서","타입으로","타입은","타입을","타입의","타입이","타입입니다.","태그","통합","특수한","특정","파싱에는","파일","파일에","파일의","팩토리","포함","포함,","포함하기","표현식","표현식에서","표현식을","표현식의","프로퍼티","프로퍼티가","프로퍼티는","프로퍼티로","프로퍼티로서","프로퍼티를","프로퍼티와","프로퍼티의","필수","필요가","하는","하드","하며","하면","하위","하위의","하지","한","할당되어야","할당할","함께","함수","함수가","함수라면","함수로","함수에서","함수의","함수이기","함수형","합니다.","합니다.jsx","합니다.jsx는","합니다.그런","합니다.이러한","합니다.프로세스가","합니다:","항목에","항상","해결하려고","해결하지","해결합니다.만약","해당","해석을","해야","허용하지","호출","확인하는","확장자","확장자가","확장자로","확장자를","확장할","환경에","환경의","활성화하세요","활용할","회상해봅시다.","흥미로운"],"pages/Decorators.html":["\"","\",","\"compileroptions\":","\"emitdecoratormetadata\":","\"es5\",","\"experimentaldecorators\":","\"greeting\");","\"hello","\"hello,","\"new","\"override\";","\"property\";","\"reflect","\"target\":","%s\")","%s\")이","'target'과","'target'으로","'value'로","(!(valu","()","(@configurable)의","(@enumerable)의","(@required)의","(accessor","(class","(decor","(f","(javascript)","(let","(method","(paramet","(parameterindex","(properti","(requiredparameters)","(target)","(target,","(target:","(value:","(예:","+","...","//","2","=","===",">=","@classdecor","@configur","@configurable(false)","@enumer","@enumerable(false)","@f","@f()","@format","@format(\"hello,","@g","@g()","@reflect.metadata","@reflect.metadata(\"design:type\",","@requir","@required와","@seal","@sealed가","@sealed을","@valid","@표현식의","[];","_p0:","_p1:","_x:","_y:","accessor,","ambient","any,","api에","argument.\");","arguments);","arguments.length","arguments[parameterindex]","boolean)","c","call","called\");","class","classdecorator(constructor:t)","color(value:","configurable(value:","console.log(\"f():","console.log(\"g():","console.log(new","const","constructor","constructor(m:","constructor(message:","constructor(x:","decorator,","decorators)","decorator가","decorator는","descriptor","descriptor.configur","descriptor.enumer","descriptor.set","descriptor.set;","descriptor.valu","descriptor.value;","descriptor:","descriptor가","descriptor는","descriptor로","descriptor에","descriptor의","design","ecmascript","emitdecoratormetadata","emitdecoratormetadata을","enumer","enumerable(value:","error(\"miss","es5","es5보다","es6의","evalu","evaluated\");","evaluation)","existingrequiredparameters,","existingrequiredparameters.push(parameterindex);","existingrequiredparameters:","experimentaldecor","extend","f()","f():","f(g(x))와","factory는","format(formatstring:","formatmetadatakey","formatstr","formatstring);","formatstring.replace(\"%s\",","function","function)","f와","g()","g():","g)(x)은(는)","getformat","getformat(target:","getformat(this,","get과","greet","greet()","greet(@requir","greeter","greeter(\"world\"));","greeter클래스의","greeting:","g을","hello","hello:","import","instanceof","javascript의","line","m;","message;","metadata","metadata\";","method","method()","method,","method.apply(this,","name","name:","new","newproperti","npm","npm을","number)","number,","number;","number[]","object,","object.seal(constructor);","object.seal(constructor.prototype);","p0()","p0(value:","p1()","p1(value:","parameterindex","parameterindex:","point","point)","point;","polyfill을","privat","properti","propertiesdecorator등에","property\";","propertydescriptor)","propertykey)","propertykey);","propertykey:","propertyname);","propertyname:","reflect","reflect.definemetadata(requiredmetadatakey,","reflect.getmetadata(\"design:type\",","reflect.getmetadata(formatmetadatakey,","reflect.getownmetadata(requiredmetadatakey,","reflect.metadata","reflect.metadata(formatmetadatakey,","requir","required(target:","requiredmetadatakey","requiredparameters)","requiredparameters:","return","save","seal","sealed(constructor:","sealed(target)","set","set(value);","stage","string","string)","string,","string;","symbol(\"format\");","symbol(\"required\");","symbol,","t)","target","target,","this._i","this._p0","this._p0;","this._p1","this._p1;","this._x","this._x;","this._y;","this.greet","this.greeting);","this.greeting;","this.hello","throw","time","true","true,","tsc","tsconfig.json:","tsconfig.json에서","type","type))","type.\");","typedpropertydescriptor)","typeerror(\"invalid","typescript","typescript는","typescript에서","typescript와","typescript의","undefined)","undefined가","valid","validate(target:","value;","x","x()","x:","x;","y()","y:","y;","{","{}","|","||","}","};","∘","가지","각","간단히","간주할","값도","값은","값을","같은","같이","것으로","것을","것입니다.","결과는","결과적인","결합합니다.","경우","경우,","공개에서","공식적으로","관리해야합니다.","관찰,","관찰하거나","관찰하는","관찰할","구문을","구분하지","구성","구성과","구성할","그","그러면","그런","그리고","기능으로","기능이","기능이며","기능입니다.","기록할","기존","기존의","기타","내의","노출됩니다.","다른","다양한","다음","다음과","다음은","단계를","단일","대상을","대신","대체합니다.","대한","대해","더욱","데","데만","데이터","데이터는","데이터를","데코레이터","데코레이터(@sealed)의","데코레이터가","데코레이터는","데코레이터를","데코레이터에","데코레이터에서","데코레이터와","데코레이터의","데코레이터입니다","데코레이팅","데코레이팅된","데코레이팅하는","도입됨에","도입할","동일한","동일합니다.","될","됩니다.","두","들어,","따라","따라서","때","때,","때문이다.","때문입니다.","또는","라이브러리가","라이브러리는","라이브러리를","라이브러리에","라이브러리의","라인","라인:","라인이나","래핑합니다.","런타임시","런타임에","로직은","매개","매개변수","매개변수가","매개변수를","매개변수에","메서드","메서드,","메서드를","메서드에","메서드을","메서드의","메커니즘이","메타","멤버에","멤버을","멤버의","모델에서","모두","모두를","모든","목록내에","무시됩니다.","뭐든","및","바꾸는","바로","반환","반환하는","반환하도록","반환하면","방법에","방법에는","방법으로","방법을","방법이","방식으로","방출하기","번째","변경","변경될","변경을","변수","변수에","변수의","별도로","볼","봉인합니다.다음은","사용됩니다.","사용하는데,","사용하도록","사용하려면","사용하여","사용할","사용합니다.이","사용해","사항을","상황이","새","생성자","생성자는","생성자를","생성자에","생성자와","서수(순서가","선언","선언,","선언과","선언되는","선언되었음을","선언됩니다.데코레이터는","선언됩니다.매개변수","선언됩니다.접근제어자","선언됩니다.클래스","선언됩니다.프로퍼티","선언에","선언에서","선언을","선언의","선언입니다.데코레이터는","선택해야하는","설명하는","설정해야","설치할","세","소개","속성","속하지","수","수정","수정할","수정합니다.","수학에서의","수행하지","수행합니다:","순서가","순서를","스크립트","시험적인","실제로","실행되면","실험적","실험적인","싶다면","아래로","아래에서","아래의","아직","않고","않습니다.","않습니다.하지만","어노테이션","어노테이션과","없고,","없기","없습니다.","여기서","여러","예를","예와","예제를","예제에는","예제에서","예제에서는","예제입니다.","예제입니다:","예제처럼","오버로드","옵션","옵션을","왜냐하면","원본","위로","위에서","위한","위해","유사합니다.이","유일한","유지하도록","의한","의해","이","이것은","이는","이니셜라이저를","이러한","이름","이름의","이어지는","인덱스","인수로","인수와","인스턴스","인해","일부","일부로","읽습니다.","임포트","있는","있는)","있습니다","있습니다.","있습니다.decor","있습니다.데코레이터는","있습니다.메서드","있습니다.이","있습니다.접근제어자","있습니다:","자세한","작동하는","작성할","작업을","작은","잘","재정의하는","적용","적용되기","적용되는","적용되며","적용되어야","적용된","적용된다.","적용됩니다.","적용됩니다.매개변수","적용됩니다.클래스","적용하는","전에","접근제어자","접근제어자,","접근제어자를","접근제어자에","접근제어자에게","정보는","정보를","정보와","정의","정의된","정의를","정의할","정적","제공되지","제공된","제공합니다.데코레이터는","제안될","제안이며","종류의","주의사항","주입합니다.","줄에:","중요한","지원을","지원하기","직전에","참고","참조하세요.","채택되도록","채택되면","첨부될","첫","초기화되는","추가적인","추가하는","추가할","추가합니다.@valid","추가합니다.getformat를","출력을","출력합니다:","커맨드","커스터마이징하고","컨텍스트","컨텍스트(예:","컴파일러","컴파일러는","콘솔에","클래스","클래스)에서","클래스가","클래스에","클래스의","타겟이","타입","타입의","통해","특별한","특정","파라미터","파일,","파일이나","팩토리","팩토리를","팩토리에","팩토리입니다","팩토리입니다.@enumerable(false)","팩토리입니다.@format(\"hello,","평가","평가는","평가되어야","평가됩니다.","평가할","포맷에","포함하고","표시하는","표준에","표준의","표현식은","표현식을","프로그래밍","프로토타입","프로토타입을","프로토타입의","프로토타입이","프로퍼티","프로퍼티가","프로퍼티를","프로퍼티에","필요에","필요한","필요합니다.","한","할","함께","함수","함수거나","함수나","함수로","함수를","함수에","함수의","함수입니다.","합니다.","합니다:","합성","항목을","해당","해보세요","해보세요...","향후","허용하지","현재","형태를","호출되며","호출되면","호출될","호출됩니다.","호출됩니다:","호출하기","호출하면","호출합니다.","확장","활성화가","활성화하려면","활성화해야"],"pages/Mixins.html":["\"","()","+","//","////////////////////////////////////////","1000);","500);",":","=","=>","[disposable,","activat","activatable]);","activate()","activate:","any,","any[])","applymixins(derivedctor:","applymixins(smartobject,","basector.prototype[name];","basectors.foreach(basector","basectors:","bookkeep","boolean","boolean;","class","console.log(this.isact","constructor()","deactivate()","deactivate:","derivedctor.prototype[name]","dispos","disposable,","disposable과","dispose()","dispose:","extend","false;","function","implement","implements를","interact()","isactive:","isdisposed:","javascript","new","object.getownpropertynames(basector.prototype).foreach(nam","oo","setinterval(()","settimeout(()","smartobj","smartobj.interact(),","smartobject","smartobject();","stand","this.activate();","this.isact","this.isdispos","this.isdisposed),","true;","typescript에서","void;","{","}","});","가능한","가져올","가지를","각","간단한","같은","개체가","거쳐","것을","것입니다.","것입니다.여러분은","것입니다.이","것입니다.이것은","결합을","결합하여","계층","구조와","구축하는","구현된","구현을","구현이","그","기능에","끝나면","능력에","다루고","다른","다음으로","대신","대한","대해","더","됩니다.","두","또","라이브러리","런타임","런타임에","마지막으로","마지막으로,","만들","만들겠습니다.","만들어냅니다.","만듭니다.이것은","맞추고","멤버를","멤버에","모델링하는","믹스인","믹스인에서","믹스인으로","믹스인을","믹스인의","믹스인이나","믹싱하여","방법은","방법을","번째로","보여줍니다.코드가","보편적인","복사하고","볼","부분의","분석해보겠습니다.","사상에","사용하여","사용한다는","사용할","사용합니다.즉,","사항을","살펴보겠습니다:","새로운","샘플","샘플은","생성합니다.이것은","소개","수","스칼라와","시작합니다.각각의","실행되며","싶은","아닌","아래","약간의","어딘가에","어떻게","언어에서의","얻고","얻을","여전히","오버헤드가","완벽한","요구","위에서","위한","위해","이","이러한","이점을","이해하기","익숙할","인기를","인터페이스로","있기는","있다는","있습니다.","있습니다.나중에는","있으며","있음을","자세히","작동하는지","작동할","재사용","전통적인","점은","정확하게는","제공해야","주목할","채우게","처리할","첫","초점을","충족시키기","충족시킵니다.비록","커뮤니티에서도","컴파일러가","컴포넌트로","코드","코드에서는","클래스로","클래스를","클래스에","클래스에서","타겟으로","타입만","타입을","특성에","특정","패턴은","프로퍼티과","프로퍼티로","프로퍼티를","하기","하지만","함께","함수를","합니다.이외에","헬퍼","활동이나","회피하고"],"pages/Triple-Slash Directives.html":["\"exports\",","\"exports\"],","\"files\"","\"legacy/modulea\"],","\"modulename\";문을","()","(function","(preprocess","(require,","(예:",".t","///","=","@type","@types,","@types/node/index.d.ts에","[\"require\",","amd","amdmodule.j","amdmodule.t","amd모듈은","c","c()","c;","class","d.t","declar","define(\"namedmodule\",","define([\"require\",","define을","depend","dependency에","export","exports)","exports,","exports.c","file","files)","function","import","import문에서","input","js","lib.d.ts)를","lib.d.ts와","modul","modulea)","modulea.callstuff()","modulea:mytyp","name","namedmodule이라는","nolib를","non","noresolv","noresolve가","out","outfile을","r.js)과","requir","return","root","skipdefaultlibcheck를","ts","tsconfig.json","tsconfig.json에서","type","typeroots와","types를","var","xml","{","}","})();","});","가장","가진","가질","간에","간주하며","같은","건너뜁니다.","검사만","것과","것은","것을","것입니다:","결과","결과적인","경로를","경우","경우에만","기본","기본적으로","기준으로","깊숙하게","나오는","내용은","넘길","다른","단계를","단일","대상이","대신","대한","대해","대해서는","더","데","도구를","뒤에","들어","때","때만","또는","또한","라이브러리","라이브러리로","라인에","라인이나","루트","루트가","를","리스트에","마찬가지로","맨","모듈","모듈에","모듈을","모듈의","모든","목록에","무시됩니다.새","문제가","미치는","발생할","방법으로도","방법은","방출됩니다.","번들(예:","변경하지도","변이들의","보세요.","보통의","본","볼","분석됩니다.","붙을","비슷합니다.","사용","사용되지","사용됩니다.","사용됩니다.파일은","사용하기를","사용하는","사용하도록","사용하세요.","사용할","사용합니다.따라서","상단에서만","생각하는","생성된","생성됩니다.이로","선언","선언된","선언을","선언의","선언하려면","선언합니다.","선택적","수","수도","수행합니다.이러한","순서대로","순서를","순서의","쉬운","슬래시","슬래시는","시","시작합니다.이것은","않는","않도록","않습니다(deprecated).","않습니다.","알려줍니다.","앞에","없는","없습니다.","여러","역할을","영향은","예를","오류","오류입니다.","오류입니다.파일에","옵션","우선으로","위에서","위치로","위해","유사합니다.트리플","유효합니다.트리플","은","을","의미는","의존성","의존성에","의존성을","이","이런","이름을","이름입니다.이러한","이상","익명으로","인해","일반적인","입니다.","입력","입력과","있는","있습니다.","있습니다.문","있습니다.이것은","있습니다:","자동으로","자세한","자체에","작성할","전달하는","전달할","전에","전처리","전처리됩니다.파일이","정렬하는","제공된","존재하지","주석","주석으로","주석은","주석입니다.주석의","주의사항:","주입해야하는","줄","중","지시자","지시자는","지시자도","지시자로","지시자를","지시자와","지시자입니다.파일","지시합니다.","지시합니다.여기에","지정되면","지정된","직접","집합으로","참조","참조가","참조는","참조하는","처리되고","처리하는","추가","추가되기","추가됩니다.","추가적인","추가하거나","추가합니다.생성된","출력","출력을","커맨드","컴파일","컴파일러","컴파일러가","컴파일러는","컴파일러에","컴파일에","코드:","타입","태그가","통과","트리플","특별한","파일","파일과","파일에","파일에서","파일은","파일을","파일의","파일이","패키지","패키지를","패키지에","패키지의","포함된","포함됩니다.트리플","포함하도록","포함하면","포함하여","포함하지","포함해야","표시합니다.이","프로세스","프로세스는","프로세스에서","프로세스와","프로퍼티을","하세요.","한","할당할","함께","합니다.","합니다.하지만","해석하기","해석하는","해석합니다.","허용합니다:","호출에","호출할","후"],"pages/Type Checking JavaScript Files.html":["\"","\"fs\"","\"react\";","\"string\";","'","'john","(!somebody)","(...arg:","(commonj","(function","(in","(unspecifi","(use","(var","(즉,","*","*/","+",".j",".js파일에는",".t","/**","//","0;","1","2);","2,","2.3","2;","3);","=","=>","@augment","@param","@t","@type","@type{array.}","@type{array}","[];","[somebody]","[x:string]:","a:","alert('hello","any)","any)가","any[])","any로","any을","any입니다.","any입니다:","arg","argument","arguments)","arguments의","array의","b","b);","b){","bar(1);","bar(1,","bar(a,","boolean을","b는","c","c();","c.prop","calls)","check","checkjs를","class","clause):","commonj","compon","console.log(a","const","constructor()","declar","default","default)","doe';","ended)","es2015/es6는","export","extend","extends에서","extend에","false;","fs","fs.readfilesync(f);","function","function(f)","getter","ignore를","import","imports로","infer","input","javascript","js","jsdoc","jsdoc)","jsdoc@augments를","jsdoc에서","jsdoc으로","jsdoc을","jsdoc의","js에서","maps으로","modul","module.exports.readfil","module.exports에","mycompon","new","nocheck","number|undefined에","number}","number}}","number에","obj","obj.b","option","p","p;","paramet","promise((resolve,","promise;","props와","react.component는","readfil","references)","reject()","reject)","render()","requir","require(\"fs\");","return","sayhello();","sayhello(somebody)","setter에","somebodi","somebody);","somebody의","state의","string은","string을","support)","this.prop","this.props.b;","this.props는","type","typescript","undefined;","undefined}","undefined를","us","var","x","x.push(\"string\");","x.push(1);","x;","x는","y","y.push(\"string\");","y.push(1);","{","{a:","{a:number}에","{component}","{number","{number}","{string}","{{a:","|","}","});","};","가능한(open","가정하며","가지","가지고","간주됩니다","간주합니다.","간주합니다.소수의","간주합니다.클래스에","값의","갖는","갖도록","갖습니다.","같은","객체","객체가","거의","건너뛸","검사","검사와","검사하는","검사하도록","것으로","것은","것을","것이","것입니다.생성자에","결합한","경우","경우가","곳은","관대한","구문을","규칙에서","규칙은","기본","기본값은","기본값은any입니다.","기본적으로","내부의","너무","다른","다음은","닫힌","대한","데","동작은","동적으로","두","두번째","들어,","들어:","따라","또는","라인의","리터럴에는","리터럴은","리터럴처럼","마찬가지로,","만","많습니다","많은","매개","매개변수","매개변수는","메서드,","멤버를","명시적으로","명시하기","몇개의","모듈","모드를","모든","목록을","못하는","무시할","문서에서","및","발생하는","방법에","방법이","방식으로","버전에서는","변경할","변수","변수는","변수를","변수에","변수의","보고","본문","본문에","본문이","부족하여","사용","사용됩니다.예를","사용으로","사용하세요.","사용하여","사용합니다.때때로","새","생성자에서","선언","선언에","선언으로","선언은","선언을","선언의","선언하는","선택사항으로","선택적","선택적으로","선택적입니다.","선택할","설정되지","설정됩니다.","설정됩니다.이런","설정하는","설정하지","소스가","속성을","수","수단이","수도","시그니처","시에는","아닌","않고","않고).j","않습니다","않습니다.","않으면","않은","알","암시적으로","어떤","없기때문에(기본값을","없는","없습니다","없습니다.","없습니다..js`","없습니다.이","없습니다.프로퍼티는","없습니다:","예.","예:","예를","오류","오류,","오류:","오류라는","오류를","오른쪽","오픈","원래","위한","위해","유추됩니다.프로퍼티","이","이것들을","이들을","이러한","이름","이후","인","인덱스","인수","인수가","인수는","인수를","인수의","인식됩니다.","인식됩니다.비슷하게,","일부","일이","읽기","입력","있는","있도록","있습니다.","있습니다.마찬가지로","있습니다.반대로","있습니다.앞","있습니다.이","있음을","있지","작업하는","적용된","전용","전체","절에","점을","정당한","정의되지","정의된","정의됩니다.","제공합니다.원래","제네릭","제외됩니다.선택사항을","제한이","조회할","존재하지","존재한다고","좋습니다.","좋아요","좋아요,","주목하는","주목할만한","주석은","주석을","주석이","줄에","중요합니다.","지원","지원되는","지원에서","지원합니다.","지정되지","지정하기","지정하는","지정하세요.","지정하여","지정하지","지정할","지정합니다.","차이점입니다:","참조를","참조에","참조에서","찾을","처리될","초기화","초기화로","추가하고","추가하는","추가하여","추가할","추론","추론된","추론하기","추론하지","추론할","클래스","클래스에","타입","타입도","타입은","타입을","타입이므로","타입입니다","특별한","특정","파일","파일로","파일에","파일에는","파일에서","파일에서와","파일의","파일처럼","패턴의","편입니다.","포맷으로","포맷은","프로세스는","프로퍼티","프로퍼티가","프로퍼티는","프로퍼티를","프로퍼티에","필요에","하는","할당됩니다.","할당에서","할당은","할당할","할당합니다.예를","함수","함수는","함수를","합법적","항상","해당","허용됨","허용됨,","허용됩니다.","허용됩니다.exports와","호출에서","호출은","호출하는","확장","흔히"],"pages/declaration files/Introduction.html":["\"하세요\"와","\"하지","api","consumpt","javascript","npm","typescript","typescript의","가이드는","가이드에서는","가지","각","각각에","간단한","감지하는","같은","개념에","개념을","것에","경우","경우에는","고급","고쳐야하는지.","공통","관리하는","관심이","구조","구조에","구조의","그것들을","기본","기본적인","기술하고,","깊숙이","나뉩니다.","네임스페이스와","높은","다음","단계를","대부분,","대상으로","대한","대해","더","도와줍니다.기존","되는","됩니다.새로운","됩니다.예제","때","라이브러리","라이브러리의","마세요\"","많은","맞는","메커니즘에","명확하고","몇","모든","문서를","미치는지를","바랍니다.","방법과","방법을","배포","배포하는","범하는","보려면","보시길","보여줍니다.이","보지","사용자는","사용자들은","사용자를","사용자의","사용할","새","선언","선언을","설명하고","설명하기","설명합니다.","설치","설치하는","섹션","섹션에서","섹션에서는","섹션으로","섹션은","섹션을","소개","수","숙련자들을","쉽게","시작점이","식별합니다,","실수를","아직","안내해","않아도","않으셨다면","않을","알아","어떤","어떻게","언어","언어에","여러","영향을","예만","예제","오류를","위해","위해,","유용한","의존성","이","이러한","이해하기","이해할","익숙하지","익숙해지게","일반적인","읽어","읽어야","읽어야합니다.","읽지","있는","있도록","있습니다.\"하세요\"와","있습니다.어떤","있을","자주","작동하는지에","작성되었습니다.","작성에","작성의","작성자는","작성하는","작성할","전제로","제공합니다.","제대로","줄","지","지식을","직관적인","직면하게","참조하세요.","찾기와","찾아","초보자를","타입과","템플릿","템플릿에서","특히","파일","파일에서","파일을","파일의","파일이","패키지를","패키지에","패턴과","편집하는","포맷과","포맷에","포맷이","품질의","피하고자","피할","하기","하도록","합니다.","합니다.아직","해당","핸드북을","활용하여보다"],"pages/declaration files/Library Structures.html":["\"","\"function\"","\"hello,","\"moment\";","\"object\"","\"prevent","\"the","\"use","$","$(()","&&","'b';","'cats',","'new'","'require'","'somelib';","'x'","(also","(b)","(either","(function","(here","(i.e.","(node.js),","(or","(root,","(see","(through","(typeof","(when",");","*","*/","+","/*","//","///","2,","2015","3];","6,","=","===","=>","['somelib'],","[1,","access","activ","actual","add","agnostic,","alter","alway","anoth","app","appli","array.prototyp","assign","assumpt","automat","avail","awar","base","be","befor","below).","both","break","briefli","broadli","browser","browser\"","built","c;","call","callabl","callable.","callable/construct","cat","catskittyset","chang","check","class.d.t","code","code.","comfort","common","commonj","commonjs,","commonjs/node.j","compil","conflict","conflict.","conflicts\"","conflicts,","consid","console.log('hello!');","console.log(moment.format());","console.log(x.startswithhello());","console.log(y.reverseandsort());","construct","constructable,","consum","consumed.","consumpt","correspond","cover","creat","creategreeting(s)","danger","declar","default","defin","define(...)","define(...,","define([\"libname\"],","define,","define.amd)","defines.","demonstr","depend","dependencies)","describ","detect","develop","direct","directive:","discourag","distinguish","document","documentation.","documentation:","doesn't","dom","due","each","easi","easier","ecmascript","effects.","enforc","ensur","environ","environment.","es2015,","es6","es6),","es6,","especi","exampl","example,","exist","exp","exp();","exp)","export","export.","expos","express","express,","extrem","factory(require(\"libname\"));","factory(root.libname);","factory)","factory);","family,","faster.","few","file","file,","file.","first","first,","follow","following:","footnot","footnote.","for,","form","fs","function","function(s)","function(somelib)","function.","function.d.t","function.d.ts.","function:","gener","general,","getthing():","give","global","global.","global.d.t","go","guid","guidanc","gulp,","hard","have.","have:","help","here","hint","however,","html","identifi","immut","impact","import","import),","import).","imported.","includ","intend","interfac","isn't","it'","it.","it:","javascript","javascript,","jquery,","keyword","kind","kittyset","known","lead","legal","level","librari","libraries,","library!","library'","library,","library.","line","list","load","loader","loader).","loaders,","lodash,","look","major","make","mani","match","member","method","modifi","modul","modular","module).","module,","module.","module.d.t","module.d.ts,","module.export","module.exports)","modules,","modules.","moment","moment.js,","moment;","more","more.","mylib.","name","namespac","need","never","new","new:","node.j","node.js\"","note","note:","notion","now","object","object.","object;","of,","offer","on","oper","organization,","other.","overview","packages.","pattern","pattern.","patterns,","plain","plugin","plugin.d.t","plugins,","policy,","popular","possibl","possible.","prevent","primit","project.","properti","properties;","purpos","purpose:","rais","rang","rare","read","real","recommend","refer","replac","represent.","request.","requir","require(\"bar\");","require(\"express\");","require(\"foo\");","require(\"fs\");","require(\"mag","require(\"moment\");","require('somelib');","require,","requirej","requirejs,","return","review","root.returnexport","rule","run","runtim","s;","same","scope","script","script.","section.","see","see:","serv","sever","shape","shim","show","signatur","signatures\"","similar","simpl","simple.","simpli","situat","small","solut","somelib","somelib.thing;","someth","somewhat","speaking,","spot","start","statement","statement:","step","still","string","string.prototyp","string.prototype.","strongli","structur","style","style.","such","sure","tag","tag:","templat","template.","test","themselv","they'r","this.","this:","three","time","time\");","today,","top","transit","turn","type","typeof","typescript","typic","umd","umd.","uncondit","unresolv","unus","us","usag","use.","used,","users.","usual","valu","vanilla","var","variabl","veri","way","way.","we'll","whatev","wherea","whether","whichev","window","window,","window.creategreet","window.somenam","without","won't","work","world\"","world\";","world.","write","write:","written","written,","x","x(\"hello\");","x(42);","y","you'll","you.","{","}","}(this,","});"],"pages/declaration files/By Example.html":["\"","\"current","\"hello","\"howdy\";","'#ff00ff'","(()","(foo","(in","(interfaces)","(type","*/","*code*","*declaration*","+",".alert(...)",".log(...)","/","/**","//","1","2","2));","3","4000","=","=>",">","```","```t","accept","access","alert","alert.","alertopt","alia","aliases)","along","anywher","api,","approxim","arr:","array.","block","boolean;","call","class","code","color:","color?:","complexity.","comput","console.log(\"half","console.log(\"th","const","const.","constructor()","constructor(greeting:","constructor.","contain","correspond","count","creat","custom","declar","declaration.","declaration:","defin","definit","describ","display","document","dot","duration:","duration?:","e.g.","exampl","expected,","explain","extend","false,","far.","file","file.","follow","foo","foo:","function","functions.","g","g.alert({","g.log({","getgreeting()","getwidget","getwidget(\"al","getwidget(43);","getwidget(n:","getwidget(s:","global","greet","greet(\"hello\");","greet(\"hello,","greet(g:","greet(getgreeting);","greet(greeting:","greet(new","greet(setting:","greet({","greeter","greeter(\"hello\");","greeter(\"hello,","greeting\"","greeting,","greeting:","greetinglib","greetinglib.opt","greetinglib.options.log","greetinglik","greetinglike):","greetings\");","greetings,","greetingset","greetingsettings):","guid","high","increas","indic","instance.","instanti","interfac","introduct","is:\"","it.","length","log","logopt","made","make","makegreet","makegreeting(s:","mandatori","method","milliseconds)","modal:","mygreet","mygreeter());","mygreeter.greet","mygreeter.showgreeting();","mygreeter;","mylib","mylib.makegreeting(\"hello,","mylib.numberofgreetings;","namespac","nest","new","notation.","number","number):","number;","numberofgreet","numberofgreetings:","object","object,","object.","on","only,","option","order","organ","overload","pass","present","present.","properti","properties.","properties:","provid","purpos","qualiti","read","refer","result","result);","return","reusabl","sampl","scoped.","shorthand","show","showgreeting():","special","specialgreet","specifi","string","string)","string):","string);","string,","string;","structur","super(\"veri","teach","them\");","time","title:","title?:","true","type","type:","types.","us","usag","user.","valu","var","variabl","variables.","verbose:","verbose?:","via","void;","well","widget","widget,","widget;","widget[]","widget[];","world\");","world\",","write","x:","{","|","}","});"],"pages/declaration files/Do's and Don'ts.html":["\"hour\");","\"more","\"pass","\"strict","'any'","'string'","'undefined'","()","(a:","(ad","(data:","(done:","*/","/*","//","1","2","2.2).",":",":)","=","=>","?","accept","accid","accomplish","allow","allowed.","alway","any)","any):","any,","any;","appear","appropri","argument","arguments.","arity:","author","b","b:","befor","beforeall(action:","boolean):","boolean,","boolean.","box","bug","c:","callback","called.","calls.","care","checking\"","choos","code,","code.","collaps","compat","consum","correctli","declar","detail","didn't","diff(one:","differ","differ.","disregard","do'","doesn't","don't","done","donefn)","earlier","effect","elapsedtim","elapsedtime:","elapsedtime?:","error","error,","exampl","example,","example;","explicit","expos","extran","faq","featur","fetcher","fewer","fine","first","fn(myelem);","fn(x.diff);","fn(x:","function","function:","gener","general\"","getobject(done:","here","hidden","htmldivelement):","htmldivelement;","htmlelement):","ignored:","import","incorrectli","instead","intend","interfac","invok","it'","it:","javascript","javascript,","k","k.dosomething();","later","legal","make","match","maximum","mean","meaning:","meant","moment","moment().utcoffset(x);","moment;","more","myelem:","need","never","non","note","null","nulls:","number)","number):","number,","number;","number|string)","number|string):","object","object,","object.","occur","ok","on","one,","oops!","option","optional:","optionals,","order","overload","overload.","overloads,","overloads:","page.","paramet","parameter,","parameter.","parameters:","pass","peopl","position:","possible:","prevent","primit","probabl","provid","put","realli","reason","reasons.","refer","resolv","return","reverse(s:","safer","same","second","see","separ","sever","shorter","signatur","signatures:","singl","someth","sort","source,","specif","strict","string):","string,","string;","target","there'","three:","three?:","through\"","timeout?:","trail","true","two","two:","two?:","type","type.","types,","typescript","typescript.","uncheck","undefin","under","union","unless","unspecifi","us","usual","utcoffset():","utcoffset(b:","valu","var","veri","void","void)","void):","void,","void;","wat?","way:","whenev","whose","why:","write","written","wrong","x","x();","x.diff(\"something\",","x:","{","}"],"pages/declaration files/Deep Dive.html":["'./foo';","(becaus","(class","(enum","(interfac","(it","(of","(or","(the","(type","*","+","...","...;","//","5;","=","a,","a.a","a.b","a.b.c,","a.y);","a:","a;,","actual","ad","add","addit","advanc","again,","alia","alias","alreadi","alway","anoth","api","appear","aspect","astut","b,","bar","bar.a;","bar:","be","behav","behavior.","behavior:","block","both","built","c","c.d;","c.x;","call","class","class)","class,","class.","class:","classes:","close","co","code:","combin","combinations:","come","complex","concept","conflict","conflict.","confusing,","console.log(a.x","console.log(x.count);","const,","constructor","consum","contain","context","contribut","conveni","count:","creat","d","declar","declaration:","declarations!","declarations.","deep","definit","depend","destructur","didn't","differ","distinct","dive","doesn't","don't","e","each","elsewher","end","enough,","entir","enum","exact","exampl","example,","excess","exist","explicit,","export","expos","expressions.","file","finally,","find","first","focus","follow","foo","foo.d.ts:","foo.sometyp","foo.somevar.a;","form","friendli","fulli","function","function).","gener","give","given","good","guid","guide,","here","here,","here.","hierarchy,","imagin","import","independent.","instanc","interest","interfac","interface.","interpret","introduc","invok","is.","isn't","it'","it.","it:","key","kind","know","legal","let'","let,","librari","lists.","long","look","m:","make","mani","mean","meanings:","member","merg","modul","more","multipl","name","name,","name.","namespac","namespace,","namespace.","namespaces).","namespaces,","namespaces.","necessarili","never","new","note","notic","number","number)","number;","number[];","object","ok","on","opportun","option","overload","particularli","perform","present","probabl","produc","properti","read","reader","realist","refer","relat","roughli","rule","runtim","s","same","second","see","seem","shape","show","side","similarly.","simpl","sn","sometyp","somevar","somevar:","sort","static","string),","string;","string;)","structur","subtl","such","surface.","targets.","that,","theory:","they'r","thing","things.","things:","though,","three","thumb","tool","tricky.","two","type","type)","type,","types,","types.","typescript","umd)","under","understand","unless","until","up","us","used.","user","valu","value,","value.","values,","values:","var","varied.","varieti","veri","want","wasn't","way","we'v","well","well.","with:","without","work","works.","write","wrote","x","x.","x.z","x:","y","y)","y:","you'd","you'll","you'r","z","z)","{","|","}","})","};"],"pages/declaration files/Templates.html":["class.d.t","function.d.t","global","global.d.t","modifi","modul","module.d.t","plugin.d.t","templat"],"pages/declaration files/Publishing.html":["\"./lib/main.d.ts\"","\"./lib/main.d.ts\",","\"./lib/main.js\",","\"1.0.0\",","\"@types/browserify\":","\"author\":","\"awesome\",","\"browserifi","\"browserify\":","\"dependencies\"","\"dependencies\":","\"devdependencies\",","\"latest\",","\"main\":","\"name\":","\"next\"","\"types\"","\"types\",","\"types\":","\"typescript\":","\"typings\"","\"vandelay","\"version\":","(next","....",".j","///","@type","@types/browserifi","addit","advis","alway","anoth","applic","approach","approch.","appropri","author","automat","browserifi","bundl","combin","command","consum","contribut","copi","declar","declarations.","definit","definitelytyp","depend","detail","devdependencies.","doesn't","don't","each","either.","example,","example:","expect","expos","extens","extension\",","favored.","field","file","file,","file.","files,","files.","find","first","flag","follow","gener","guide,","guidelin","hand,","here,","https://github.com/definitelytyped/definitelytyped.","imagin","includ","index.d.t","index.js)","indic","industries\",","information.","instal","instead.","javascript","keep","library,","line","live","main","make","manag","manual","mark","more","name","need","note","now","npm","npm.","npm:","organ","otherwis","packag","package,","package.json","package.json.","package:","packages,","packages.","page.","pleas","point","prefer","properti","property,","publish","pull","reason,","red","request","revisit","root","second","section","set","so.","step","submit","sure","sync.","synonym","those","those,","though","time","tool.","two","type","typescript","typescript,","typescript.","under","us","user","way","way,","well.","written","yours,","{","}"],"pages/declaration files/Consumption.html":["\"","\");","\"lodash\";","*","2.0","2.0,","20,","@type","@types/,","@types/lodash","_","_.","_.padstart(\"hello","abov","acquiring,","alreadi","alway","apart","back","becom","both","check","code","code.","command","consum","consumpt","contribut","correspond","declar","declarations,","definitelytyp","describ","detail","details.","develop","download","easier","ed","exactli","example,","favorit","file","files,","find","follow","fuss.","get","global","guidelin","help","https://aka.ms/typ","import","includ","instal","it.","librari","library.","lodash","look","modul","modules,","more","name","need,","needed.","next","note","note:","noth","npm","npm,","npm.","on","onc","out","packag","page","part,","pleas","prefix","present,","publishing,","requir","same","save","search","see","significantli","take","them.","three.","tool","type","typescript","typescript!\",","us","using,","variabl","work","worth","write","you’ll","you’r","you’v"],"pages/tsconfig.json.html":["\"**/*.spec.ts\"","\"../../built/local/tsc.js\",","\"./configs/base\",","\"./tsconfig\",","\"@types\"","\"binder.ts\",","\"checker.ts\",","\"commandlineparser.ts\",","\"commonjs\",","\"compileonsave\":","\"compileroptions\"","\"compileroptions\":","\"core.ts\",","\"diagnosticinformationmap.generated.ts\"","\"emitter.ts\",","\"exclude\"","\"exclude\":","\"exclude\"는","\"exclude\"에","\"express\"]","\"extends\":","\"files\"","\"files\":","\"files\"과","\"foo\"","\"include\"","\"include\":","\"include\"을","\"lodash\",","\"main.ts\",","\"module\":","\"node_modules\",","\"noimplicitany\"","\"noimplicitany\":","\"outfile\":","\"parser.ts\",","\"preserveconstenums\":","\"program.ts\",","\"removecomments\":","\"scanner.ts\",","\"sourcemap\":","\"src/**/*\"","\"strictnullchecks\":","\"supplemental.ts\"","\"sys.ts\",","\"system\",","\"tsc.ts\",","\"typeroots\"","\"types\"","\"types\":","\"types.ts\",","\"utilities.ts\",","&","(.ts,.d.t","(compileroptions,files,includ","(configur","(디렉토리","(또는","(모듈로","(예:","*","**/","*만",".","../../node_modules/@types/","../node_modules/@types/,","./node_modules/@types/,","./node_modules/@types/express만","./node_modules/@types/lodash","./node_modules/@types/node,","./node_modules/@types의","./typings의",".d.t",".json",".jsx).",".jsx)도",".js와",".ts,",".tsx",".tsx)","/","0개","1.8.4","2015에서",":","?","@type","@types,","[","[\"./typings\"]","[\"node\",","[]를","]","],","a.ts가","a.ts에","allowj","atom","b.ts가","b.ts는","bower_components,","compileonsav","compileonsave를","configs/base.json:","exclude는","exclude와","extend","extends)","extends는","extends를","fals","files,","foo","glob","http://json.schemastore.org/tsconfig에서","ide에","import","includ","index.d.t","index.d.ts와","index.js는","index.ts가","inherit","js","jspm_packag","node_modul","node_modules,","node_modules/@typ","p)","package.json가","project","separ","studio","true","true,","true로","tsconfig.json","tsconfig.json:","tsconfig.json에","tsconfig.json은","tsconfig.json의","tsconfig.json파일을","tsconfig.nostrictnull.json:","tsc를","tsc와","type","typeroot","typeroots를","typescript","typescript는","types을","visual","{","}","},","가진","간주됩니다.구체적으로","값은","값이","갖습니다.\"include\"와","갖습니다.지원되는","같습니다:","같은","개요","검색합니다.","것으로","것은","것을","것이","것입니다.","결합(union)을","경로","경로가","경로는","경로를","경로의","경우","경우,","경우에만","관계없이","구분에","권장하지","그","그리고","기능은","기본","기본적으로","기본적으로(위에서","기본적으로는","기본적인(위에서","기준으로","나란히","나열된","나타냅니다.tsconfig.json","다르게","다른","다음","다음과","달리).예를","대신","대한","덮어씁니다.","데","두","두는","들어","들어:","등의","디렉토리","디렉토리가","디렉토리에","디렉토리에서부터","디렉토리와","디렉토리의","또","또는","라인","라인에","로드된","루트","루트임을","를","리스트에서도","맞닥뜨리면","매칭","먼저","명시적으로","명심하세요","모두","모든","목록과","목록보기","목록을","무시됩니다.","문을","문자열입니다.","문자와","및","반복적으로","방법","보고","보고합니다.상속","비슷하게,","비어있을","비워","사용","사용됩니다.지원되는","사용하는","사용하여","사용한다면","사용해","상대적","상대적이거나","상세","상속","상속되는","상속받을","상속할","상위","생략될","생성합니다.","선언된","선언이","설명","설명한대로)","설정","설정되면","설정시","설정에","설정을","설정이","설정하면","속성","속성에","속성은","속성을","속성이","수","스키마","스키마는","시","시작하여","실행할","아래에","아래의","않는","않다는","않습니다.","않은","않을","없는","없습니다.","없이","여전히","예를","예제","오류를","오버라이드합니다.","오직","옵션으로","옵션은","옵션을","옵션의","와일드카드는","완전히","원래","유효한","의미합니다.","의해","이","이상과","이상의","이어지며","이용한","입니다.extends'","입력","입력에","있는","있던","있습니다.","있습니다.그러나","있습니다.기본","있으며","있지","자동","자동으로","장애와","재정의됩니다.순환성","저장","전역","전체","절대적인","점에","제외)","제외된","제외될","제외됩니다.","제외됩니다.일반적으로","제외합니다.","제외합니다.allowjs가","존재한다는","주의해야","중","중요하다는","지원됩니다.","지원하는","지정되어","지정되지","지정된","지정하는","지정하면","지정할","지정합니다.","참조","참조되는","찾을","체인으로","최상위","출력","커맨드","컴파일됩니다:","컴파일러","컴파일러는","컴파일러에는","컴파일러의","컴파일에","컴파일하는","컴파일합니다.","통해","파일","파일(.js와","파일과","파일도","파일들:","파일들은","파일만","파일에","파일에는","파일에서","파일은","파일을","파일의","파일이","패키지가","패키지는","패키지를","패키지만","패턴의","포함되며","포함되면","포함되어","포함되지","포함된","포함됩니다","포함됩니다.","포함됩니다.\"exclude\"","포함됩니다.동봉된","포함시킵니다.\"exclude\"","포함이","포함하는","포함합니다.\"outdir\"","포함합니다.node_modules/@types/*","폴더","폴더를","폴더에","폴더의","폴더입니다.","표시된","프로젝트는","프로젝트를","프로젝트의","플러그인이","필드를","필요한","필터링할","하나로","하위","한","함께)","합니다.즉","항상","해당","해석됩니다.","허용하십시오.","현재","호출하거나","호출하는","확장자","확장자만"],"pages/Compiler Options.html":["\"amd\"","\"amd\",","\"amd\"와","\"classic\"","\"commonjs\"","\"commonjs\",","\"crlf\"","\"es2015\"","\"es2016\",","\"es2017\"","\"es3\"","\"es5\"","\"es5\",","\"es6\"","\"es6\",","\"es6\"/\"es2015\",","\"es6\"와","\"esnext\".","\"esnext\".►","\"esnext\"는","\"lf\"","\"node\"","\"none\",","\"preserve\"","\"preserve\".","\"react\"","\"react.createelement\"","\"system\"","\"system\",","\"system\"만","\"umd\",","\"use","\"utf8\"","#1232","#2577","(\"ts.transpilemodule\"과","(us):","(공통","(기본값),","(예.","(윈도우)","(유닉스).\"","(인코딩","(특정","*/",".d.t",".j",".map",".tsx","/*!로","/**","0","8",":","===","?","@intern","@types,","[1]","[2]","__extends,","__extends와","__rest,","__spread에","allowj","allowjs에만","allowjs와","allowsyntheticdefaultimport","allowunreachablecod","allowunusedlabel","alwaysstrict","alwaysstrict,","any만","baseurl","baseurl을","bivari","boolean","br","charset","check","checkj","chinese:","cn","const","copi","createelement와","cs","czech:","d","de","declar","declarationdir","default","deprec","destructur","diagnost","disablesizelimit","dom","dom,es5,scripthost","dom,es6,dom.iterable,scripthost","dom.iter","downleveliter","ecmascript","emitbom","emitdecoratormetadata[1]","emit을","en","english","enum","es","es2015","es2015.collect","es2015.cor","es2015.gener","es2015.iter","es2015.promis","es2015.proxi","es2015.reflect","es2015.symbol","es2015.symbol.wellknown","es2016","es2016.array.includ","es2017","es2017.object","es2017.sharedmemori","es2017.typedarray","es3를","es5","es5:","es6","es6:","es7","esnext","esnext.asynciter","esnext.promis","experimentaldecorators[1]","export가","fallthrough","fals","file","files].","for..of,","forceconsistentcasinginfilenam","fr","french:","german:","h","h.","help","importhelp","imports를","init","inlinesourc","inlinesourcemap","input","isolatedmodul","italian:","iter","ja","japanese:","javascript","jsdoc","json","jsx","jsxfactori","jsxfactory를","jsx를","ko","korean:","lib","librari","lib가","listemittedfil","listfil","local","m","maproot","maxnodemodulejsdepth","modul","moduleresolut","msbuild","newlin","node.js/io.j","node_modul","noemit","noemithelp","noemitonerror","noerrortrunc","nofallthroughcasesinswitch","noimplicitani","noimplicitany,","noimplicitreturn","noimplicitthi","noimplicitthis,","noimplicitusestrict","nolib","noresolv","nostrictgenericcheck","nounusedloc","nounusedparamet","null","null과","number","object","out","outdir","outdir로","outfil","outfile과","outfile을","p","paths[2]","pl","polish:","portuguese(brazil):","preserveconstenum","preservesymlink","pretty[1]","project","pt","react.createel","reactnamespac","removecom","right","rootdir","rootdirs[2]","ru","russian:","scripthost","simplifi","skipdefaultlibcheck","skiplibcheck","skiplibcheck를","sourcemap","sourcemap에","sourcemap을","sourceroot","spanish:","spread","strict","strict\"","strict\"을","strictfunctiontyp","strictfunctiontypes이","strictnullcheck","strict를","string","string[]","stripinternal[1]","suppressexcesspropertyerror","suppressimplicitanyindexerror","symlinked된","symlinks를","t","target","tr","traceresolut","tradit","tsconfig.json","tsconfig.json를","tsconfig.json에서만","tslib로부터","turkish:","tw","type","typeroot","typescript","types를","undefin","us.","utf","v","version","void에","w","watch","webwork","zh","►","가능하다는","가능한","가능합니다.","가지","가진","각","값은","값이","같습니다:","같은","객체","객체를","건너뛰기[default","건너뜁니다.","검사","검사를","검사에","검색할","것입니다).","결정.","결정됩니다.","결합된","경로","경로로","경로에","경로일","경우","경우,","관련).","관련된","관련사항","구문","구조를","그","그리고","기능을","기본","기본값","기준으로","깊이.","끝의","나열합니다.","나타내는","내보내지","내보낼","내보냅니다.","내에서","내용은","다룹니다.","다른","다시","다음과","단일","단지","대상","대상으로","대상을","대신","대한","대해","데","데이터를","데코레이터","데코레이터에","도메인에","도움말을","동일한","되었습니다.","등..)","디렉토리","디렉토리.","디렉토리는","디렉토리로","디렉토리를","디렉토리의","디렉토리입니다.","디버거가","디버거를","디버깅","때","또는","또한","라이브러리","라이브러리는","라이브러리의","라인","라인에서는","런타임","런타임에","레이블에","로그","로드","루트","리다이렉트합니다.","리스트가","리스트에서","리액트","리터럴에","매개","매개변수를","매핑","맵","맵과","맵에","맵으로","메세지","메세지를","메시지를","메타","모듈","모듈로","모듈에서","모드로","모드에서는","모든","목록.","목록과","목록에","목록을","목록입니다.","목록입니다.가능한","문서를","문서을","문에","문자열","및","바이트","반복","반환값이","발생시킵니다.","방법","방출된","방출에는","방출을","방출하지","방출합니다.","버전","버전을","변경","변수에","변환합니다","별도의","보고된","보고하지","보고합니다.","보여줍니다.","부분에","불과합니다.","불리하여","비","비슷합니다).","비활성화합니다.","사용:","사용되는","사용되지","사용하도록","사용하세요.","사용하여","사용하지","사용할","사용합니다.","사용합니다.\"react\"","사용합니다.기본","사이즈","삽입됩니다.","상대적","색상","생성","생성된","생성하지","생성합니다.","선언","선언에","선언을","설계","설명","설정","설정하기","설정해야","소스","소스가","소스를","소스에","수","수도","순서","순서는","순서표(bom)를","스위치","스타일","스타일을","슬래시","시","시그니처","시그니처가","시그니처의","시작","시작하는","시점에","시퀀스","실제","실행합니다.","실험단계입니다.","실험적인","아닌","아래에서","않고","않는","않습니다.","않으며","않으면","암시한","억제합니다.","엄격한","없는","없을","연결의","연결하여","연결할","열거형","영향을","예:","예외사항은","오류","오류가","오류를","옵션","옵션은","옵션을","와치","와치하여","위치","위치가","위치는","위치를","위치에","위치할","위한","위해","위해서만","유효한","의존성","이","이름을","이름의","이슈를","이슈을","이하를","인덱스","인덱싱하는","인수는","일관성이","일부로","임포트","임포트와","임포트합니다.","입력","있고","있는","있습니다(한","있습니다.","있습니다.►","있습니다.자세한","있지","자세한","자체와","적용됩니다.","전달된","정보를","정의가","제거합니다.","제공합니다.","제네릭","제안","제어하기","제외한","제한을","주석을","주의사항:","주입되는","주지","줄이지","중","중지합니다.","지시자를","지역","지역화,","지우지","지원:","지원을","지정:","지정되지","지정된","지정하기","지정한","지정합니다.","진단","집합입니다","참조","참조는","참조하세요.","찾아야","처리됩니다)","초과","초기화하고","최대","최신","추가하지","출력","출력에","출력에서는","출력을","출력합니다.","커맨드","커스텀","컨텍스트를","컨텐츠가","컴파일","컴파일된","컴파일러","컴파일러를","컴파일러에","컴파일러의","컴파일에","컴파일의","컴파일하세요.이","컴파일합니다.","케이스에","코드","코드에","타입","타입에","타입에서","타입으로","타입의","트리플","파싱을","파일","파일(*.d.ts)의","파일(lib.d.ts)은","파일과","파일로","파일에","파일에서","파일을","파일의","파일이","파일처럼","팩토리","포함되어","포함된","포함될","포함됩니다.","포함하지","폴더","폴더의","표시하는","표현식과","표현식에","프로젝트를","프로젝트에서","프로젝트의","프로퍼티","플랫폼)","하고","하나입니다.","하는","할","할당","할당할","함께","함수","함수를","함수의","합니다.","해당하는","해석","해석의","해석하기","해석하지","허용되며","허용되지","허용하지","허용합니다","허용합니다.","헤더","헬퍼","헬퍼를","호출된","확인하세요.","활성화하면","활성화합니다."],"pages/Compiler Options in MSBuild.html":["(x86)\\msbuild\\microsoft\\visualstudio\\v$(visualstudioversion)\\typescript\\microsoft.typescript.target","(예:","(이","1.7","1.7).이렇게","allowj","allowsyntheticdefaultimport","allowunreachablecod","allowunusedlabel","alwaysstrict","amd,","baseurl","boolean","c:\\program","charset","classic","commonjs,","crlf","declar","declarationdir","diagnost","disablesizelimit","emitbom","emitdecoratormetadata","es3,","es5,","es6","experimentalasyncfunct","experimentaldecor","f5키를","fals","file","forceconsistentcasinginfilenam","help","importhelp","init","inlinesourc","inlinesourcemap","isolatedmodul","jsx","jsxfactori","lf","lib","listemittedfil","listfil","local","maproot","maxnodemodulejsdepth","modul","moduleresolut","msbuild","msbuild에서","msbuild에서의","newlin","node","noemit","noemithelp","noemitonerror","nofallthroughcasesinswitch","noimplicitani","noimplicitreturn","noimplicitthi","noimplicitusestrict","nolib","noresolv","nostrictgenericcheck","nounusedloc","nounusedparamet","out","outdir","outfil","path","preferreduilang","preserv","preserveconstenum","preservesymlink","pretti","react","reactnamespac","removecom","rootdir","skipdefaultlibcheck","skiplibcheck","sourcemap","sourceroot","strict","strictfunctiontyp","strictnullcheck","string","stripintern","studio","suppressexcesspropertyerror","suppressimplicitanyindexerror","system","target","toolsvers","traceresolut","true","true를","tsc","ts를","type","typeroot","typescriptadditionalflag","typescriptallowsyntheticdefaultimport","typescriptallowunreachablecod","typescriptallowunusedlabel","typescriptalwaysstrict","typescriptbaseurl","typescriptcharset","typescriptcompileblock","typescriptdeclarationdir","typescriptemitbom","typescriptemitdecoratormetadata","typescriptexperimentalasyncfunct","typescriptexperimentaldecor","typescriptforceconsistentcasinginfilenam","typescriptgeneratesdeclar","typescriptimporthelp","typescriptinlinesourc","typescriptinlinesourcemap","typescriptisolatedmodul","typescriptjsxemit","typescriptjsxfactori","typescriptlib","typescriptmaproot","typescriptmodulekind","typescriptmoduleresolut","typescriptnewlin","typescriptnoemithelp","typescriptnoemitonerror","typescriptnofallthroughcasesinswitch","typescriptnoimplicitani","typescriptnoimplicitreturn","typescriptnoimplicitthi","typescriptnoimplicitusestrict","typescriptnolib","typescriptnoresolv","typescriptnostrictgenericcheck","typescriptnounusedloc","typescriptnounusedparamet","typescriptoutdir","typescriptoutfil","typescriptpreserveconstenum","typescriptpreservesymlink","typescriptreactnamespac","typescriptremovecom","typescriptrootdir","typescriptskipdefaultlibcheck","typescriptskiplibcheck","typescriptsourcemap","typescriptsourceroot","typescriptstrict","typescriptstrictfunctiontyp","typescriptstrictnullcheck","typescriptstripintern","typescriptsuppressexcesspropertyerror","typescriptsuppressimplicitanyindexerror","typescripttarget","typescripttoolsversion이","umd,","visual","vs와","watch","xml","값","값은","개발을","개요","걸프,","경로","경우","구분된","그런트","그리고","기능은","내의","눌러도","다른","대한","데","도구를","동일한","등)","디버깅","또는","로드","만약","맵핑","맵핑이","메시지가","모든","목록","무엇일까요?","문자열","버전에서","버전을","버전의","빌드","빌드가","빌드를","빌드하는","빌드합니다.","사용자에게는","사용하는","사용하여","사용할","사이의","설정","설정하세요.","설치된","속성","속성을","수","쉼표로","시","식별합니다","신뢰할","않습니다","않습니다.","않으면","업그레이드하라는","여기에","여러분의","예제","예제에서는","옵션","옵션은","위한","이렇게","이름","있는","있습니다.","자동","자동으로","전용","제공되지만","제한된","지원되는","지원되지","지원이","지정되지","지정할","첫","최신","컴파일러","컴파일러에","컴퓨터에","태그와","파일","파일을","파일의","편집","표시됩니다","프로젝트","프로젝트가","프로젝트를","프로젝트에서","하면","허용된","허용합니다.","확인하세요.msbuild","환경을"],"pages/Integrating with Build Tools.html":["\"!node_modules/**/*.ts\"]","\"./src/index.tsx\",","\".js\"]","\".ts\",","\".tsx\",","\".web.js\",","\".webpack.js\",","\"bundle.js\"","\"output.js\"","\"output.js\")","\"t","'.ts'","'.ts'와","'.tsx'","'.tsx'를","'t","()","(err)","(err,","(맨",".add(\"main.ts\")",".bundle()",".entry(\"entry.ts\")",".pipe(process.stdout);",".pipe(ts({",".plugin(\"tsify\",",".run(funct",".use(typescript())","//","/\\.tsx?$/,","0.16beta",":","=",">","[","[\"\",","[\"**/*.ts\",","[\"ts\"]);","]","api","awesom","basic","browserifi","browserify()","build","bundle.j","default","dev","duo","duo(__dirname)","entry.t","entry:","err;","extensions:","fals","filename:","frankwallis/duo","fs","fs.writefilesync(out,","function","function(grunt)","g","grunt","grunt.initconfig({","grunt.loadnpmtasks(\"grunt","grunt.registertask(\"default\",","gruntfile.j","gulp","gulp.src(\"src/*.ts\")","gulp.task(\"default\",","gulpfile.j","instal","ivogabe/gulp","jspm","jspm@beta","jspm의","loader","loader\"","loader'에","loader:","loaders:","loader에","main.t","manag","microsoft.typescript.default.prop","microsoft.typescript.msbuild를","microsoft.typescript.target","module.export","module:","msbuild","nightli","noimplicitani","noimplicitany:","npm","nuget","nuget과","out","out:","output:","p","packag","path","path.join(__dirname,","require(\"browserify\");","require(\"duo","require(\"duo\");","require(\"fs\")","require(\"gulp","require(\"gulp\");","require(\"path\")","require(\"tsify\");","resolve:","results)","results.code);","return","save","smrq/tsifi","src:","test:","throw","true","true,","ts","ts\");","ts:","tsifi","tsresult","tsresult.js.pipe(gulp.dest(\"built/local\"));","typescript","typescript\");","typescriptsamples/jspm","typestrong/grunt","us","var","webpack","webpack.config.j","{","}","})","}));","});","},","};","가능한","가진","검색하세요","결과를","기본","내용:","내용은","다시","다이얼로그와","대안:","대한","도구들","도구와","또는","라인","로컬에","매니저","모든","빌드","사용","설정","설치","설치가","설치된","아래)","업데이트하여","여기를","옵션","완료되면","우","위)와","의해","인터페이스","입니다.","자세한","작성합니다.","정의에","주의사항:","지원은","참조하세요.","처리됩니다.","추가합니다.","출력","커맨드","컴파일된","컴파일러","클릭","통합","파일에","파일은","파일을","패키지","포함하도록","프로젝트","프로젝트의","하세요!","하세요:","해석","현재","확장자로","확장자를"],"pages/Nightly Builds.html":["\"/node_modules/typescript/lib\"","\"typescript.tsdk\":","\"typescript_tsdk\":","&","(mac)","(microsoft.typescript.targets,","(tsc.exe,",".",".vscode/settings.json","/node_modules/typescript/lib","/usr/local/lib/node_modules/typescript/lib","12","14","2013","2013:","2015","2015:",">","build에는","code","drop을","framework","g","id","idea","ide를","instal","intellij","languag","lib.d.ts,","master","microsoft.typescript.compiler:","microsoft.typescript.default.props,","microsoft.typescript.msbuild:","midnight까지","msbuild","msbuild에","nightli","nightlies는","node_modul","npm","npm과","npm을","nuget","nuget를","nuget에","packages:","powershel","prefer","pst","set","studio","sublim","text","text를","tsscript","two","typescript","typescript@next","typescript@next가","typescript를","typescript의","user","visual","vs","vscode","vsdevmode.ps1","www.myget.org에서","가능합니다.","가정합니다.","가져올","같은","같이","경우:","구성을","구성해야","기반으로","나머지","내용은","노력하고","다운로드.","다음과","다음을","대부분의","대상","대한","도구를","도구만","도구뿐만","등.)","또한","라인","로컬","문서를","및","배포됩니다.다음과","배포하기","버전:","버전의","변경","부분에서는","브랜치의","빌드","빌드는","빌드를","사용","사용에","사용하도록","사용하여","사항에는","새로운","서비스","선택합니다:","설정이","설치","설치되어","설치하거나","설치한","설치할","설치해야","섹션의","수","수도","스크립트","실행합니다:","아니라","않지만","언어","업데이트","업데이트하세요:","업데이트할","없습니다.","위와","위키","위한","위해","이","이미","이용","있다고","있습니다.","있습니다.먼저","있지","자세한","작업","전역으로","전체","주의사항:","참조하세요.","참조하십시오.","창에서","커맨드","커스텀","통해","파일","파일을","패키지를","페이지를","포함되어","폴더에","프로그램을","프로젝트","프로젝트를","플러그인","플러그인을","필요는","함께","합니다.","합니다.npm","현재"]},"length":41},"tokenStore":{"root":{"0":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002779064381658175},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"}":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"b":{"1":{"0":{"1":{"0":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"o":{"7":{"4":{"4":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}},"x":{"docs":{},"f":{"0":{"0":{"docs":{},"d":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"docs":{}},"docs":{}}},"부":{"docs":{},"터":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.003242241778601204},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},".":{"1":{"6":{"docs":{},"b":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}},"docs":{}},"5":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"docs":{}},"]":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"개":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"1":{"0":{"0":{"0":{"docs":{},"}":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},")":{"docs":{},";":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"1":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687}},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}}}},"1":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.005094951366373321},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}},"]":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"진":{"docs":{},"수":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"a":{"docs":{},"m":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}},"}":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"1":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}},"2":{"3":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"3":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436}}}},"}":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"4":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"6":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"진":{"docs":{},"수":{"docs":{},"와":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},"7":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0073059360730593605},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},".":{"1":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},".":{"2":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"docs":{}}},"3":{"6":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"docs":{}},"5":{"docs":{},"에":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"서":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"7":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},")":{"docs":{},".":{"docs":{},"이":{"docs":{},"렇":{"docs":{},"게":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}},"8":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},".":{"4":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"docs":{}}},"docs":{}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}}}}}}}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445}}},"x":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"을":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"이":{"docs":{},"어":{"docs":{},"야":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"2":{"0":{"1":{"3":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},":":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"5":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.011111111111111112},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"년":{"docs":{},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"에":{"docs":{},"서":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"부":{"docs":{},"터":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},":":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"7":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}},"이":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"docs":{}},"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},",":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986}}}},"2":{"6":{"1":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"docs":{}},"docs":{}},"6":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"8":{"0":{"8":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"docs":{}},"2":{"4":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"docs":{}},"docs":{}},"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},"]":{"docs":{},";":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}},"와":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"진":{"docs":{},"수":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},".":{"0":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}},",":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}},"2":{"docs":{},")":{"docs":{},".":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}},"3":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"docs":{}},"}":{"docs":{},")":{"docs":{},"}":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},";":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"3":{"2":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"4":{"docs":{},"m":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"5":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"7":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"에":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"]":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"}":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},")":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"개":{"docs":{},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"4":{"0":{"0":{"0":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},"docs":{}},"docs":{}},"5":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},")":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869}}},"}":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"5":{"0":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"docs":{}},"2":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}}}},"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0025811209439528023},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}},"분":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":2.5}}},"]":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"값":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},".":{"0":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}},"docs":{}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"m":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"x":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"6":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"]":{"docs":{},";":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"7":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}},"8":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"진":{"docs":{},"수":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}},"9":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"]":{"docs":{},"+":{"docs":{},"$":{"docs":{},"/":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}}}}}}},"docs":{},"d":{"3":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},".":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}},":":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"는":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}},"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"e":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"v":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003927729772191673},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}},"b":{"docs":{},"u":{"docs":{},"g":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"g":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00663716814159292},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"s":{"docs":{},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}},"i":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.006352087114337568},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"e":{"docs":{},"(":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},"[":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}}}}}},"\"":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}}}}}}}}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},".":{"docs":{},"a":{"docs":{},"m":{"docs":{},"d":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"을":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"s":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"i":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}}}}}}}}},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}},"(":{"docs":{},"[":{"docs":{},"'":{"docs":{},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"/":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"*":{"docs":{},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},"'":{"docs":{},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.010889292196007259},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.037800687285223365}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"y":{"docs":{},"에":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0024679170779861796}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0024679170779861796}}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005917159763313609},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.014519056261343012},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.05543710021321962},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.01393188854489164},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.03367875647668394},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.06529209621993128},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.04195804195804196},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167}}},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"으":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"!":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}},",":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}},"k":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0036781609195402297}},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"객":{"docs":{},"체":{"docs":{},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"s":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735}}}},"가":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}},"a":{"docs":{},"d":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}}},":":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}}}}}}}}}}},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"e":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0034944670937682005}}},"가":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002}}},"로":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735}}},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}},"b":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"[":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"]":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}},"s":{"docs":{},".":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}}}},"e":{"docs":{},"p":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":5.001295336787565}}}}},"o":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00353045013239188},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.007259528130671506},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.019189765458422176}},".":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008417508417508417}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"y":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"\"":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}}}}}}}}}}}}}}}}}}}}},"의":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.003629764065335753}}},":":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}}}}}},"m":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"\"":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},";":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"과":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"을":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}}},"의":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},",":{"docs":{},"e":{"docs":{},"s":{"5":{"docs":{},",":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}},"6":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}},".":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"g":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},".":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"1":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"docs":{}},"docs":{}}}}}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},")":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}}}},"w":{"docs":{},"n":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"m":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"'":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"s":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},"'":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":5}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":5.012383900928793},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.010309278350515464}}}},"e":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},"f":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}}}}},"i":{"docs":{},"v":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"e":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":5.001295336787565}}}},"s":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"/":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"b":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}}}}},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}}}}}}}}}}},"의":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"c":{"docs":{},"t":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.015584415584415584}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}},"과":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}}},":":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}}}}},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.005479452054794521},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"u":{"docs":{},"p":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"]":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}}}}}}}},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"y":{"docs":{},")":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.006476683937823834}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"가":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}},"t":{"docs":{},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},".":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}},"(":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.006191950464396285}}}}}}}}},"d":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}},"a":{"docs":{},"g":{"docs":{},"n":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}},"x":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"y":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474}}}},"a":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"d":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},".":{"docs":{},"t":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"u":{"docs":{},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165}}},"?":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}},"o":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0182370820668693}},"(":{"docs":{},"_":{"docs":{},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"을":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}},"h":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"을":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}},"의":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}},"에":{"docs":{},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}},"v":{"docs":{},"e":{"docs":{},"m":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"l":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"e":{"docs":{},"s":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}},"가":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},":":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"r":{"docs":{},"d":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},".":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}},"]":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}}}},"'":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},".":{"docs":{},".":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"이":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}},")":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}},")":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}}}}}}}}}}}}}}},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"g":{"docs":{},"o":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"f":{"docs":{},"w":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},"/":{"docs":{},"?":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"5":{"1":{"8":{"0":{"0":{"7":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"/":{"docs":{},"t":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"/":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"k":{"docs":{},"a":{"docs":{},".":{"docs":{},"m":{"docs":{},"s":{"docs":{},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.00909090909090909},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005177514792899409},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"x":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}},"s":{"docs":{},")":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"p":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"x":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}},"r":{"docs":{},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"r":{"docs":{},"s":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"i":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}},"과":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"?":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"s":{"docs":{},")":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}},"n":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}}}}}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"j":{"docs":{},"a":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"v":{"docs":{},"a":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.005341880341880342},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":2.501283697047497},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}},"가":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":5.00056338028169},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"와":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}},"파":{"docs":{},"일":{"docs":{},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"이":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"와":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}},"s":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"x":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":10.013313609467456},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.004180602006688963},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0036982248520710057},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"와":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},".":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005177514792899409}},";":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}},"[":{"docs":{},"]":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"에":{"docs":{},"서":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}}}}}}}}}}},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}},"에":{"docs":{},"서":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036}}},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"y":{"docs":{},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.011553273427471117},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"@":{"docs":{},"a":{"docs":{},"u":{"docs":{},"g":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}}},"에":{"docs":{},"서":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"으":{"docs":{},"로":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"을":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}},"에":{"docs":{},"서":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"p":{"docs":{},"m":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}},"@":{"docs":{},"b":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}},"의":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},"o":{"docs":{},"n":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}}},"y":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"라":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}}}}}},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"m":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"s":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"측":{"docs":{},"의":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.01},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0121580547112462},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}},"에":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"서":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0425}},"의":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":3.333333333333333}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"까":{"docs":{},"지":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"p":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"s":{"docs":{},",":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}}}}}}},"m":{"docs":{},"s":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"를":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},":":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}}}}}},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"x":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.013745704467353952}},".":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"s":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"y":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"i":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.007259528130671506},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}},"p":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.005681818181818182},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0022955523672883787}},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"s":{"docs":{},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"[":{"docs":{},"'":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"'":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}},"과":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}},"(":{"docs":{},"f":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},".":{"docs":{},"j":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"t":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"s":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}},"t":{"docs":{},"h":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"x":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"x":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436}}}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}}}}}}}}}}},"x":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}}}},"p":{"docs":{},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}}},"docs":{}}}}}}}}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"c":{"docs":{},"h":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}},"}":{"docs":{},"`":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"k":{"docs":{},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"d":{"docs":{},"e":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{},"u":{"docs":{},"m":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"j":{"docs":{},"s":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"k":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004659289458357601}},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.004537205081669692},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"(":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}}},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}},"e":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}},")":{"docs":{},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"s":{"docs":{},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"에":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"r":{"docs":{},"g":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}},"a":{"docs":{},"n":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.007772020725388601}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}},"s":{"docs":{},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}}}}},"t":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},")":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"u":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.008480825958702065},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0070140280561122245},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.03539019963702359},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.007772020725388601},"pages/declaration files/Templates.html":{"ref":"pages/declaration files/Templates.html","tf":0.23076923076923078},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/Templates.html":{"ref":"pages/declaration files/Templates.html","tf":0.15384615384615385}},"s":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"a":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814}}}}}}}}}}}}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}}},")":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},":":{"docs":{},"m":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}},"b":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148}}}},"a":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.003629764065335753}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.006352087114337568},"pages/declaration files/Templates.html":{"ref":"pages/declaration files/Templates.html","tf":0.07692307692307693}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"s":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}},"_":{"1":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156}}}}}}}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"_":{"1":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"docs":{}}},"docs":{}},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.006396588486140725}}}}}},"n":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"`":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"z":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}}}}},"v":{"docs":{},"e":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0029615004935834156}},"(":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078}}}}}}}}}}}}}}}}}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"e":{"docs":{},"v":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}}}}}},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.003629764065335753},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148}}}}}},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135}}},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.007739938080495356},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},"y":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}},"[":{"0":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"2":{"docs":{},"]":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"docs":{}}}}}},"d":{"docs":{},"d":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"f":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}}}}}}}}}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005917159763313609},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"가":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687}}}}}},"t":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}},"[":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},")":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}}}}}}}}}},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0034940600978336828}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"과":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}},";":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"e":{"docs":{},".":{"docs":{},"d":{"docs":{},"o":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}},"i":{"docs":{},"b":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"p":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}}}}},"k":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909}}}}}},"(":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"p":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}},"y":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"p":{"0":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}}}}}}},"1":{"docs":{},".":{"docs":{},"x":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"(":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}}}}}}},"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"r":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}},"o":{"docs":{},"j":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"2":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"docs":{}}}}}}},"2":{"docs":{},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"3":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"docs":{}}}}}}},"docs":{}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"2":{"docs":{},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"3":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"docs":{}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"$":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"/":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"라":{"docs":{},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"의":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"과":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"(":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}}},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}},"p":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.008528784648187633},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.007772020725388601},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"등":{"docs":{},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}},"y":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002}}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004076878276062901}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}},"s":{"docs":{},"의":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},";":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"와":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"'":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.004442250740375123},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"멤":{"docs":{},"버":{"docs":{},"가":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"에":{"docs":{},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"?":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}},"x":{"docs":{},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}},"f":{"docs":{},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"y":{"docs":{},"(":{"docs":{},"o":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"y":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"o":{"docs":{},"f":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"s":{"docs":{},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}},"b":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"s":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"r":{"docs":{},"v":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"와":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"m":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}},"n":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},",":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}}}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}},"[":{"1":{"docs":{},"]":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"docs":{}}},"i":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875}}}}},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"t":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}}}}}}}}}},"m":{"docs":{},"y":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}}}}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}},"m":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"a":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.005923000987166831},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0034944670937682005}},"e":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"멤":{"docs":{},"버":{"docs":{},"가":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}},"으":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"이":{"docs":{},"다":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"와":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.010835913312693499}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"라":{"docs":{},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"e":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}},",":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}},".":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"h":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"처":{"docs":{},"럼":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}}}}},",":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"?":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.058419243986254296},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.03496503496503497},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}},"가":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}},"s":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}}},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}},"c":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}}}},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}}},":":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}}},"g":{"docs":{},"e":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"s":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}},".":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}},"t":{"docs":{},"h":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"?":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"s":{"docs":{},"[":{"2":{"docs":{},"]":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"docs":{}}},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"_":{"docs":{},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.003629764065335753}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},"s":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}},"s":{"docs":{},"s":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135}},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},".":{"docs":{},"b":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"c":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"가":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.002582496413199426}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}}}}}}},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}}}}}}}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284}},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367}}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},";":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.005050505050505051},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"(":{"docs":{},"\"":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}},"i":{"docs":{},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"으":{"docs":{},"로":{"docs":{},"부":{"docs":{},"터":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"[":{"docs":{},"'":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"'":{"docs":{},"]":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"타":{"docs":{},"입":{"docs":{},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}},"p":{"docs":{},"]":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}},"]":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"?":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}},"e":{"docs":{},"r":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"k":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},"e":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.011111111111111112}},".":{"docs":{},"f":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}}}},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{},"e":{"docs":{},"g":{"docs":{},"g":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}}}}}}}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"s":{"docs":{},")":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408}}},"[":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.006734006734006734},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0029615004935834156},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020086083213773313},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"와":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"으":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"s":{"docs":{},"h":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":10.02405498281787}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}}}}}}},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"e":{"docs":{},":":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"l":{"docs":{},"l":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"3":{"docs":{},"d":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0034944670937682005}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"가":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}}}}}},"l":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"을":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}},"g":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"s":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}}}}}}},"e":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.003629764065335753}},"e":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0054446460980036296}}}}}}},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"g":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"z":{"docs":{},"i":{"docs":{},"l":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}},".":{"docs":{},"i":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"x":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"i":{"docs":{},"e":{"docs":{},"c":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"c":{"docs":{},"k":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}},"(":{"1":{"5":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}},"docs":{}},"docs":{},"x":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}}}},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"1":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}}}}},"2":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}}}}},"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.005057471264367816}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}}}}},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}}}}}}}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436}}}}}}}},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"l":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"u":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"o":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}}}}}},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"으":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.008166969147005444}},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/Templates.html":{"ref":"pages/declaration files/Templates.html","tf":0.15384615384615385}}}}}},"s":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},")":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"s":{"docs":{},"t":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"t":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.01816911250873515},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.011764705882352941},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.006352087114337568},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.021321961620469083},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.02631578947368421},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.03367875647668394},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.013745704467353952},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.02097902097902098},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.045454545454545456},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":2.516835016835017},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.00906344410876133},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.007069913589945012},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.007323943661971831},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.017045454545454544},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.003006012024048096},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.015810276679841896},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.006191950464396285},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.01718213058419244},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.02097902097902098},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005681818181818182},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0243161094224924},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.013824884792626729}},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}}},"가":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.002582496413199426},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}}}}}}}}}}},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.003943661971830986},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.006734006734006734},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}}}},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"도":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"의":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"는":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"!":{"docs":{},"\"":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},",":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986}}}}},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}},"와":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"처":{"docs":{},"럼":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"보":{"docs":{},"다":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"s":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"j":{"docs":{},"s":{"docs":{},"p":{"docs":{},"m":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}},".":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"b":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"x":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}},"o":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"m":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"s":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"이":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}},"@":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"가":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}}},"i":{"docs":{},"p":{"docs":{},"r":{"docs":{},"t":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.002582496413199426}},"에":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"를":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}},",":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004}}},"을":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"/":{"docs":{},"g":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"o":{"docs":{},"f":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0022955523672883787},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148}}}},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"에":{"docs":{},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},".":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"n":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"s":{"docs":{},"와":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"를":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},"\"":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}},"이":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"s":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"은":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"을":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"c":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148}}}}}},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"y":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"{":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002}}},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}},"x":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"y":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"e":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}},"i":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"p":{"0":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}},"1":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}},"docs":{}},"x":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"y":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.003948667324777887}},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"s":{"docs":{},"[":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.01038961038961039}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}},"e":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}}}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}},"b":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}}}},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}}}}}}}}}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.003218390804597701},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149}}},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.003218390804597701},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"와":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}},":":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0054446460980036296}}}},"n":{"docs":{},"g":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"\"":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}},"e":{"docs":{},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}},"?":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}},".":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0034550839091806516}}},"으":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}},"r":{"docs":{},"e":{"docs":{},"!":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"\"":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"'":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}},"m":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"v":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}},".":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}},"y":{"docs":{},"'":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}},"s":{"docs":{},"e":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}},"s":{"2":{"3":{"0":{"7":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"docs":{}},"4":{"5":{"docs":{},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.015197568389057751}},"c":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":10.012784090909092},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"서":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"만":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"파":{"docs":{},"일":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"을":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}},"n":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}}}}}}}}}}}}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"와":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.006284367635506678},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00911854103343465}}},"y":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},".":{"docs":{},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"로":{"docs":{},"부":{"docs":{},"터":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"를":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},":":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}},"g":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"라":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},":":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735}}},"s":{"docs":{},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}}},"k":{"docs":{},"e":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.008166969147005444},"pages/declaration files/Templates.html":{"ref":"pages/declaration files/Templates.html","tf":10}},"e":{"1":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148}}}}}}},"o":{"docs":{},"r":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}}}},"s":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"s":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"(":{"docs":{},"c":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"t":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"b":{"docs":{},"o":{"docs":{},"x":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}},"를":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"c":{"docs":{},"h":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"u":{"docs":{},"e":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005681818181818182},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00911854103343465}},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.00906344410876133},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0054988216810683424},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.011363636363636364},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"}":{"docs":{},")":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.01038961038961039}}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}},"로":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}}},"i":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505}},"e":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"과":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}},"c":{"docs":{},"k":{"docs":{},"y":{"docs":{},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}},"e":{"docs":{},"e":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}}}}}}}}}}}},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}}}},"i":{"docs":{},"l":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"c":{"docs":{},"k":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"m":{"docs":{},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"3":{"4":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"docs":{}},"docs":{}}}}}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"m":{"docs":{},"i":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"p":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.006352087114337568}},"i":{"docs":{},"c":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"?":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135}}}}}}}}},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},"?":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165}}}}}}}},")":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.009084556254367574},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0034940600978336828},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"[":{"docs":{},"]":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},")":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"k":{"docs":{},"]":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"[":{"docs":{},"]":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}},"p":{"docs":{},"]":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"}":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"w":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"o":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}},"?":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}},"]":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}},"?":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"와":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"으":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"이":{"docs":{},"며":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},"k":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}},"간":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"단":{"docs":{},"한":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.005050505050505051},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"가":{"docs":{},"장":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"다":{"docs":{},"음":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"예":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"게":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"히":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"략":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"섭":{"docs":{},"하":{"docs":{},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"주":{"docs":{},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}}},"몇":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"구":{"docs":{},"체":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}},"된":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"되":{"docs":{},"어":{"docs":{},"야":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"지":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}},"사":{"docs":{},"실":{"docs":{},"상":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"그":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"또":{"docs":{},"한":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"소":{"docs":{},"수":{"docs":{},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}},"할":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"하":{"docs":{},"며":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}},"결":{"docs":{},"하":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"접":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"에":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"감":{"docs":{},"사":{"docs":{},"하":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}}}}}},"싸":{"docs":{},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"기":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"져":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"지":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"모":{"docs":{},"듈":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"하":{"docs":{},"는":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},"쌀":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"같":{"docs":{},"은":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.009577464788732394},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004545454545454545},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.005917159763313609},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.003875968992248062},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.00501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"이":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003927729772191673},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0033812341504649195},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.013824884792626729}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"인":{"docs":{},"터":{"docs":{},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}},"아":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"야":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"기":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"으":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},"개":{"docs":{},"발":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"을":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"자":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"들":{"docs":{},"이":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"에":{"docs":{},"게":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"도":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"가":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"에":{"docs":{},"게":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"할":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"수":{"docs":{},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}},"념":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}},"과":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"지":{"docs":{},"만":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"은":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948}}},"에":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"요":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"별":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}},"체":{"docs":{},"가":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"검":{"docs":{},"색":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"량":{"docs":{},"과":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},"한":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}},"할":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}},"사":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":2.501283697047497},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00422654268808115},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"나":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}},"되":{"docs":{},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"며":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"서":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"하":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"기":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"여":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"도":{"docs":{},"록":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}},"타":{"docs":{},"입":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"그":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"런":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}},"기":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"는":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"를":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"해":{"docs":{},"야":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"만":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"와":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}},"경":{"docs":{},"우":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.006197183098591549},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.003242241778601204},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0036815462494247586},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0045662100456621},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.004651162790697674},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0022955523672883787},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0029498525073746312},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0045090180360721445},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00441306266548985},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0036982248520710057},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004659289458357601},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006109979633401222},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.008522727272727272},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"는":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"도":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"만":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"입":{"docs":{},"이":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"x":{"docs":{},"의":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"와":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}},"조":{"docs":{},"차":{"docs":{},"도":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"\"":{"docs":{},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"했":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0225}},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"가":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}},"로":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"인":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"일":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}},"험":{"docs":{},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"공":{"docs":{},"식":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"백":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}},"유":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"지":{"docs":{},"만":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"한":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}}}}}}},"통":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},"점":{"docs":{},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"적":{"docs":{},"인":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}},"학":{"docs":{},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"개":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"구":{"docs":{},"글":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}},"문":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"나":{"docs":{},"중":{"docs":{},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"으":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"조":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948}},"가":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"와":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"화":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"하":{"docs":{},"기":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"적":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837}},"인":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}},"를":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},"의":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"에":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"현":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"할":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"된":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}},"하":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"여":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"한":{"docs":{},"다":{"docs":{},"고":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"해":{"docs":{},"야":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}},"체":{"docs":{},"로":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"되":{"docs":{},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"지":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"서":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"은":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"이":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"성":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"여":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"해":{"docs":{},"야":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"캡":{"docs":{},"처":{"docs":{},"된":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"이":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}},"원":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"요":{"docs":{},"소":{"docs":{},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"과":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"할":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"체":{"docs":{},"적":{"docs":{},"일":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"인":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},"으":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"축":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"되":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"하":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}}},"을":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"별":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"하":{"docs":{},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"분":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"지":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"할":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"에":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"된":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"규":{"docs":{},"칙":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"은":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"을":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"서":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"과":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"모":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}},"그":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0033802816901408453},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"냥":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"러":{"docs":{},"면":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"나":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"기":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"런":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"트":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"리":{"docs":{},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"를":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}}}},"레":{"docs":{},"이":{"docs":{},"션":{"docs":{},"에":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"렇":{"docs":{},"지":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"다":{"docs":{},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}},"기":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"것":{"docs":{},"들":{"docs":{},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"을":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"들":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"럼":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"에":{"docs":{},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"룹":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"으":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"화":{"docs":{},"할":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"이":{"docs":{},"며":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"의":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"대":{"docs":{},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"래":{"docs":{},"서":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"도":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"저":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"럴":{"docs":{},"듯":{"docs":{},"한":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"기":{"docs":{},"여":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}},"할":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"초":{"docs":{},"적":{"docs":{},"인":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}}},"능":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"들":{"docs":{},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"이":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002}},"지":{"docs":{},"만":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"며":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"으":{"docs":{},"로":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}},"반":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005917159763313609}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"구":{"docs":{},"조":{"docs":{},"적":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"본":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":5},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0029615004935834156},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.005057471264367816},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005681818181818182},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.005134788189987163},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}},"(":{"docs":{},"위":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"인":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948}},"(":{"docs":{},"위":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}},"값":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"과":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"으":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}},"이":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"며":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"존":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00441306266548985},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"록":{"docs":{},"하":{"docs":{},"도":{"docs":{},"록":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"여":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"할":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"술":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"한":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"하":{"docs":{},"지":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"고":{"docs":{},",":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}},"대":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"할":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"다":{"docs":{},"리":{"docs":{},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"지":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"사":{"docs":{},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"억":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"?":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}}}}}}}},"해":{"docs":{},"야":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"한":{"docs":{},"다":{"docs":{},"면":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}},"법":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"분":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"명":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},"타":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002}}},"준":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"으":{"docs":{},"로":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"계":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}},"깃":{"docs":{},"헙":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}},"다":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"양":{"docs":{},"한":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"시":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.005050505050505051},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"운":{"docs":{},"로":{"docs":{},"드":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"할":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},".":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"그":{"docs":{},"레":{"docs":{},"이":{"docs":{},"드":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}},"음":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.012084592145015106},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0035070140280561123},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.008736167734420501},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"과":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.007049345417925478},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.004713275726630008},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0033812341504649195},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.006012024048096192},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00353045013239188},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"른":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00507185122569738},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00555812876331635},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0041417395306028535},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0034940600978336828},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0045662100456621},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.004591104734576757},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00331858407079646},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.004273504273504274},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.00250501002004008},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00794351279788173},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006109979633401222},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005681818181818182},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}}},"루":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"게":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"었":{"docs":{},"던":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"르":{"docs":{},"게":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}},"소":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"룰":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"룹":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"이":{"docs":{},"번":{"docs":{},"에":{"docs":{},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}},"름":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"릅":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"행":{"docs":{},"스":{"docs":{},"럽":{"docs":{},"게":{"docs":{},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}}}},"히":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"형":{"docs":{},"성":{"docs":{},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"이":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"수":{"docs":{},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"이":{"docs":{},"얼":{"docs":{},"로":{"docs":{},"그":{"docs":{},"와":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}},"단":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"어":{"docs":{},"를":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}},"일":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0025811209439528023},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00353045013239188},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},"지":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"축":{"docs":{},"형":{"docs":{},"태":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}}}}},"계":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"에":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"만":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}},"언":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036}},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}}}},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}}},"순":{"docs":{},"한":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"화":{"docs":{},"할":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"하":{"docs":{},"고":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"히":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"위":{"docs":{},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"점":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"은":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"항":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}}},"서":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"대":{"docs":{},"체":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.00250501002004008}},"로":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"는":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"일":{"docs":{},"단":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}},"한":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.004713275726630008},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004545454545454545},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002779064381658175},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0041928721174004195},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.007444168734491315},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00331858407079646},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.004273504273504274},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.011945392491467578},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.00501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.016307513104251603},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.010183299389002037},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.005134788189987163},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"신":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0041928721174004195},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.004180602006688963}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}}}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"하":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},")":{"docs":{},"를":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"상":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.004651162790697674},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"의":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"으":{"docs":{},"로":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.011111111111111112},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.004180602006688963}}}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"이":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"부":{"docs":{},"분":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},",":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},"해":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"만":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"는":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}},"비":{"docs":{},"하":{"docs":{},"여":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"답":{"docs":{},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"은":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"수":{"docs":{},"롭":{"docs":{},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"의":{"docs":{},"(":{"docs":{},"a":{"docs":{},"l":{"docs":{},"g":{"docs":{},"e":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"c":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}},"응":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"이":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"하":{"docs":{},"여":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"형":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"안":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},":":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"조":{"docs":{},"적":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}},"규":{"docs":{},"모":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505}}}},"문":{"docs":{},"자":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},".":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.015209125475285171},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}},"j":{"docs":{},"s":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}},"숙":{"docs":{},"련":{"docs":{},"된":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"앞":{"docs":{},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"참":{"docs":{},"조":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"새":{"docs":{},"로":{"docs":{},"운":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},"예":{"docs":{},"제":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}}},"두":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0033812341504649195},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002779064381658175},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.005426356589147287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020086083213773313},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00617828773168579},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0036982248520710057},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.007792207792207792},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}}}}},"가":{"docs":{},"지":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"번":{"docs":{},"째":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"개":{"docs":{},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"면":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"어":{"docs":{},"야":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"등":{"docs":{},"록":{"docs":{},"을":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}},"과":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}},"장":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"하":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"으":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"의":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},".":{"docs":{},".":{"docs":{},")":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},")":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}}},")":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"릴":{"docs":{},"리":{"docs":{},"즈":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}}},"많":{"docs":{},"이":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"거":{"docs":{},"나":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0033812341504649195},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948}}},"아":{"docs":{},"지":{"docs":{},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"!":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"모":{"docs":{},"던":{"docs":{},"하":{"docs":{},"게":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}}},"든":{"docs":{"./":{"ref":"./","tf":0.01818181818181818},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0033802816901408453},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0125},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00422654268808115},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0024679170779861796},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002758620689655172},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.008385744234800839},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0031563845050215206},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0022123893805309734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.005341880341880342},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0035070140280561123},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.014204545454545454},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.004180602006688963},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"두":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"에":{"docs":{},"서":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"듈":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Modules.html":{"ref":"pages/Modules.html","tf":10.010693215339233},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":5.01877133105802},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":5.018537074148297},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00529567519858782},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006109979633401222},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.005134788189987163},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.00919732441471572}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.006012024048096192},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"이":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.008532423208191127},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},"라":{"docs":{},"고":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.00250501002004008},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00331858407079646},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"\"":{"docs":{},"은":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505}}},")":{"docs":{},"를":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"과":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"만":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"별":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"은":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.004056047197640118},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00331858407079646},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.008532423208191127},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"성":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"인":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"델":{"docs":{},"링":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"하":{"docs":{},"기":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"는":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"은":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"에":{"docs":{},"서":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"르":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"지":{"docs":{},"만":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"릅":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"렇":{"docs":{},"게":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}},"아":{"docs":{},"서":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"을":{"docs":{},"수":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"습":{"docs":{},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"방":{"docs":{},"하":{"docs":{},"려":{"docs":{},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}},"일":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"드":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"가":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0036982248520710057}}},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"로":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"문":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"서":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.004180602006688963},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}},"의":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"을":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"자":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.005479452054794521}},"열":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.002582496413199426},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"인":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}},"의":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}},"어":{"docs":{},"야":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"와":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}},"제":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"없":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"들":{"docs":{},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"점":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"장":{"docs":{},"과":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"안":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"맥":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543}}}}}},"은":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"및":{"docs":{"./":{"ref":"./","tf":0.01818181818181818},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.005050505050505051},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003927729772191673},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0033812341504649195},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.003875968992248062},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.00250501002004008},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.008522727272727272},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.005852842809364548},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}},"밖":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"도":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"버":{"docs":{},"전":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"에":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"서":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"을":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"과":{"docs":{},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},":":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"튼":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627}}}}},"그":{"docs":{},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"이":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"즉":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}},"리":{"docs":{},"게":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"블":{"docs":{},"링":{"docs":{},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}},"번":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"역":{"docs":{"./":{"ref":"./","tf":0.01818181818181818}},"가":{"docs":{},"이":{"docs":{},"드":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}},"며":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}}},"도":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}},"을":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}},"이":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}},"하":{"docs":{},"는":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}},"할":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}}}}}}}}}}}}}}}},"째":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00353045013239188},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"로":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"들":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"링":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"이":{"docs":{},"나":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"(":{"docs":{},"묶":{"docs":{},"는":{"docs":{},")":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"(":{"docs":{},"묶":{"docs":{},"어":{"docs":{},"서":{"docs":{},")":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}},"예":{"docs":{},":":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"호":{"docs":{},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"만":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"범":{"docs":{},"위":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}},"하":{"docs":{},"는":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},"부":{"docs":{},"분":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}},"과":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"이":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"인":{"docs":{},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"의":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"서":{"docs":{},"는":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}},"르":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"가":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"동":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}}},"여":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"하":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"전":{"docs":{},"개":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}},"해":{"docs":{},"야":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"울":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}}},"재":{"docs":{},"도":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"정":{"docs":{},"확":{"docs":{},"한":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"릅":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"매":{"docs":{},"개":{"docs":{},"변":{"docs":{},"수":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"다":{"docs":{},"른":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"적":{"docs":{},"절":{"docs":{},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"한":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"함":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"수":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"터":{"docs":{},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"족":{"docs":{},"하":{"docs":{},"여":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}},"브":{"docs":{},"랜":{"docs":{},"치":{"docs":{},"에":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}},"의":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"라":{"docs":{},"우":{"docs":{},"저":{"docs":{},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}},"가":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}}},"들":{"docs":{},"은":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"와":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"레":{"docs":{},"이":{"docs":{},"크":{"docs":{},"포":{"docs":{},"인":{"docs":{},"트":{"docs":{},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}},"사":{"docs":{},"용":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.015197568389057751},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}},"이":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"되":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"지":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"며":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"든":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"어":{"docs":{},"야":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"도":{"docs":{},"록":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"자":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}},"가":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"들":{"docs":{},"은":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"에":{"docs":{},"게":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"는":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.003943661971830986},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0034940600978336828},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}},"것":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"데":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"여":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.005050505050505051},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0033802816901408453},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004545454545454545},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0029615004935834156},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.003218390804597701},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0041928721174004195},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0022955523672883787},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.00641025641025641},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.005511022044088177},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00441306266548985},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004659289458357601},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.006418485237483954},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0075},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"기":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"를":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"겠":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"면":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"도":{"docs":{},"록":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.018433179723502304}}}},"려":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"면":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"고":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"세":{"docs":{},"요":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}},"앞":{"docs":{},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}},"\"":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}},"만":{"docs":{},"일":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"였":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}},"지":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"만":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"거":{"docs":{},"나":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"므":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"며":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"할":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004545454545454545},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00507185122569738},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0029615004935834156},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.007686932215234102},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020086083213773313},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0055309734513274336},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.008547008547008548},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.008532423208191127},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004437869822485207},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.006988934187536401},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"r":{"docs":{},"t":{"docs":{},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"와":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}}}}},"스":{"docs":{},"코":{"docs":{},"프":{"docs":{},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"각":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"둘":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"여":{"docs":{},"기":{"docs":{},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"이":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"것":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"즉":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"(":{"docs":{},"주":{"docs":{},"의":{"docs":{},"사":{"docs":{},"항":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}},"화":{"docs":{},"살":{"docs":{},"표":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"자":{"docs":{},"세":{"docs":{},"히":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"실":{"docs":{},"용":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"내":{"docs":{},"장":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"따":{"docs":{},"라":{"docs":{},"서":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}},"때":{"docs":{},"때":{"docs":{},"로":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"기":{"docs":{},"본":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"(":{"docs":{},"즉":{"docs":{},"시":{"docs":{},"실":{"docs":{},"행":{"docs":{},"함":{"docs":{},"수":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"했":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"음":{"docs":{},"을":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"다":{"docs":{},"면":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"어":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"에":{"docs":{},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}}}},"한":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"다":{"docs":{},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},".":{"docs":{},"이":{"docs":{},"러":{"docs":{},"한":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}}}}},"때":{"docs":{},"로":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"세":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"한":{"docs":{},"편":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}},"선":{"docs":{},"택":{"docs":{},"적":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"파":{"docs":{},"일":{"docs":{},"은":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}},"예":{"docs":{},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"지":{"docs":{},"원":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"으":{"docs":{},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"될":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"해":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}},"야":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"한":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"법":{"docs":{},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"된":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"은":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"과":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"에":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"전":{"docs":{},"을":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}},"에":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"이":{"docs":{},"트":{"docs":{},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"에":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"서":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"클":{"docs":{},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"의":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"즈":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"라":{"docs":{},"지":{"docs":{},"려":{"docs":{},"면":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"항":{"docs":{},"은":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"이":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"라":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"며":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"므":{"docs":{},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"에":{"docs":{},"는":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"람":{"docs":{},"들":{"docs":{},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"본":{"docs":{},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"실":{"docs":{},"일":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"만":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"례":{"docs":{},"들":{"docs":{},"을":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"양":{"docs":{},"에":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"을":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"상":{"docs":{},"에":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"상":{"docs":{},"황":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"적":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.009925558312655087}}},"이":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"자":{"docs":{},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}},"태":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"\"":{"docs":{},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"대":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.004008016032064128}},"적":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.003006012024048096},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"으":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"인":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064}},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"이":{"docs":{},"거":{"docs":{},"나":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}},"응":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496}}}}},"위":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"의":{"docs":{},"하":{"docs":{},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"속":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"받":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"으":{"docs":{},"며":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"여":{"docs":{},"기":{"docs":{},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}},"을":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"하":{"docs":{},"지":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"즉":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"되":{"docs":{},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"할":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"호":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"관":{"docs":{},"없":{"docs":{},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"수":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0136986301369863}},"들":{"docs":{},"을":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}},"초":{"docs":{},"기":{"docs":{},"화":{"docs":{},"되":{"docs":{},"어":{"docs":{},"야":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}},"당":{"docs":{},"히":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"단":{"docs":{},"에":{"docs":{},"서":{"docs":{},"만":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}},"세":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"선":{"docs":{},"정":{"docs":{},"이":{"docs":{},"나":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}}},"언":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":5.0027790643816585},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":5.005295675198588},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.008736167734420501},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.012219959266802444},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.05138339920948617},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00441306266548985},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004076878276062901},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"된":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00353045013239188},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"했":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"그":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002779064381658175},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00529567519858782},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"한":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"다":{"docs":{},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"과":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"도":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"되":{"docs":{},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875}}},"어":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"야":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"었":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"음":{"docs":{},"을":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"될":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"데":{"docs":{},"코":{"docs":{},"레":{"docs":{},"이":{"docs":{},"터":{"docs":{},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}},"매":{"docs":{},"개":{"docs":{},"변":{"docs":{},"수":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"접":{"docs":{},"근":{"docs":{},"제":{"docs":{},"어":{"docs":{},"자":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"프":{"docs":{},"로":{"docs":{},"퍼":{"docs":{},"티":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}},"들":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"없":{"docs":{},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0034944670937682005},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"으":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"부":{"docs":{},"터":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"라":{"docs":{},"고":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"든":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"전":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"데":{"docs":{},"코":{"docs":{},"레":{"docs":{},"이":{"docs":{},"터":{"docs":{},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}},"하":{"docs":{},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"전":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"였":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}},"면":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"려":{"docs":{},"면":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"매":{"docs":{},"개":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"각":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},"만":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"문":{"docs":{},"은":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"적":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"해":{"docs":{},"야":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"택":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"게":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}},"기":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"적":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004137931034482759},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.004651162790697674},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006109979633401222},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}}},"인":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"다":{"docs":{},"음":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"그":{"docs":{},"러":{"docs":{},"나":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"타":{"docs":{},"입":{"docs":{},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}},"사":{"docs":{},"항":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}},"으":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}}}}},"한":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"할":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}},"사":{"docs":{},"용":{"docs":{},"자":{"docs":{},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"이":{"docs":{},"러":{"docs":{},"한":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},":":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}},"이":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"해":{"docs":{},"야":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}},"호":{"docs":{},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"도":{"docs":{},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"되":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}},"소":{"docs":{},"개":{"docs":{"./":{"ref":"./","tf":10},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":10}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"스":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.005681818181818182},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0045090180360721445},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.005016722408026756}},"맵":{"docs":{},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"수":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}}},"위":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"속":{"docs":{},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"러":{"docs":{},"한":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}},"프":{"docs":{},"트":{"docs":{},"웨":{"docs":{},"어":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"문":{"docs":{},"자":{"docs":{},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"수":{"docs":{"./":{"ref":"./","tf":0.01818181818181818},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.020202020202020204},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.012568735271013355},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.025915492957746478},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.014772727272727272},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.028740490278951817},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.018063918480778138},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.017947537965945698},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.01678183613030602},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.014712643678160919},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.023759608665269043},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0136986301369863},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.009302325581395349},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.016642754662840747},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.012905604719764012},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.01282051282051282},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.013026052104208416},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.01323918799646955},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.016272189349112426},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.018637157833430402},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.01038961038961039},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.008146639511201629},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.01797175866495507},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.011857707509881422},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.009943181818181818},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}},"도":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0050704225352112674},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002779064381658175},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"준":{"docs":{},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"에":{"docs":{},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},"정":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}},"합":{"docs":{},"시":{"docs":{},"다":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"하":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"면":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"세":{"docs":{},"요":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"해":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"야":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}},"된":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"없":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"행":{"docs":{},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"했":{"docs":{},"다":{"docs":{},"고":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"오":{"docs":{},"버":{"docs":{},"로":{"docs":{},"드":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"이":{"docs":{},"러":{"docs":{},"한":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"하":{"docs":{},"고":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"지":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"각":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"동":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"와":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"퍼":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"있":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"직":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"학":{"docs":{},"에":{"docs":{},"서":{"docs":{},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"단":{"docs":{},"이":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"순":{"docs":{},"위":{"docs":{},"로":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}},"차":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"서":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"대":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814}}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"가":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"의":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"는":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"표":{"docs":{},"(":{"docs":{},"b":{"docs":{},"o":{"docs":{},"m":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}},"쓰":{"docs":{},"이":{"docs":{},"는":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}},"지":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"인":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"않":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}},"다":{"docs":{},"면":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"았":{"docs":{},"다":{"docs":{},"면":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}},"으":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"을":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"기":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},")":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}},"도":{"docs":{},"록":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"으":{"docs":{},"면":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"므":{"docs":{},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"며":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"려":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"면":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"셨":{"docs":{},"다":{"docs":{},"면":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}},"은":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00353045013239188},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.006418485237483954},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"(":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"다":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"면":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0425}},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005681818181818182},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.011705685618729096},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"대":{"docs":{},"신":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"런":{"docs":{},"타":{"docs":{},"임":{"docs":{},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},"예":{"docs":{},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"실":{"docs":{},"제":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"(":{"docs":{},"역":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"왜":{"docs":{},"냐":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"아":{"docs":{},"래":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"유":{"docs":{},"니":{"docs":{},"온":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"컴":{"docs":{},"파":{"docs":{},"일":{"docs":{},"러":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}},"권":{"docs":{},"장":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"사":{"docs":{},"용":{"docs":{},"하":{"docs":{},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"파":{"docs":{},"일":{"docs":{},"의":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"현":{"docs":{},"재":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}},"다":{"docs":{},"만":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"(":{"docs":{},"명":{"docs":{},"확":{"docs":{},"한":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}}}}}}}},"—":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"아":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"야":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"더":{"docs":{},"라":{"docs":{},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"거":{"docs":{},"나":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"지":{"docs":{},"만":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"음":{"docs":{},")":{"docs":{},".":{"docs":{},"즉":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}},"어":{"docs":{},"렵":{"docs":{},"거":{"docs":{},"나":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"노":{"docs":{},"테":{"docs":{},"이":{"docs":{},"션":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"은":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"과":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}},"떠":{"docs":{},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}},"떤":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"떻":{"docs":{},"게":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948}}}},"플":{"docs":{},"리":{"docs":{},"케":{"docs":{},"이":{"docs":{},"션":{"docs":{},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"에":{"docs":{},"서":{"docs":{},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}},"쩌":{"docs":{},"면":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"디":{"docs":{},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"에":{"docs":{},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}},"색":{"docs":{},"함":{"docs":{},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"려":{"docs":{},"울":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"움":{"docs":{},"이":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"딘":{"docs":{},"가":{"docs":{},"에":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}},"언":{"docs":{},"제":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"나":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}},"든":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"급":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"했":{"docs":{},"듯":{"docs":{},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"기":{"docs":{},"본":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}},"하":{"docs":{},"지":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"또":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}},"할":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"어":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"에":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"처":{"docs":{},"럼":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"의":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"와":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"처":{"docs":{},"럼":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"단":{"docs":{},"일":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"래":{"docs":{},"핑":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},"(":{"docs":{},"푸":{"docs":{},"는":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"예":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"정":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}},"상":{"docs":{},"대":{"docs":{},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}},"치":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"할":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"한":{"docs":{},"대":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"하":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"즉":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}},"되":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}},"제":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}}}}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"가":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}},"부":{"docs":{},"터":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"와":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"처":{"docs":{},"럼":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.003875968992248062},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.00250501002004008},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.007702182284980745},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636}}},"술":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"외":{"docs":{},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"사":{"docs":{},"항":{"docs":{},"은":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"방":{"docs":{},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"측":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"로":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},".":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"네":{"docs":{},"임":{"docs":{},"스":{"docs":{},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}},":":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.009925558312655087},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"시":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}},"와":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"와":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"만":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"오":{"docs":{},"역":{"docs":{},"과":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}},"류":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0041928721174004195},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004437869822485207},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705}},"가":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.007525083612040134}}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002758620689655172},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0022955523672883787},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0024679170779861796},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724}}},"!":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},")":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"파":{"docs":{},"일":{"docs":{},"에":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"라":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"른":{"docs":{},"쪽":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"으":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},"늘":{"docs":{},"날":{"docs":{},"에":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"버":{"docs":{},"로":{"docs":{},"드":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"만":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"함":{"docs":{},"으":{"docs":{},"로":{"docs":{},"써":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}},"라":{"docs":{},"이":{"docs":{},"드":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"하":{"docs":{},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}},"딩":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"헤":{"docs":{},"드":{"docs":{},"가":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}},"면":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"직":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"래":{"docs":{},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"염":{"docs":{},"과":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"픈":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"우":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"선":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"순":{"docs":{},"위":{"docs":{},"가":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},"으":{"docs":{},"로":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}},"리":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"가":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"에":{"docs":{},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"발":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"회":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"측":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"연":{"docs":{},"한":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}},"견":{"docs":{"./":{"ref":"./","tf":0.01818181818181818}}},"미":{"docs":{},"론":{"docs":{},"적":{"docs":{},"인":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"w":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"와":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"또":{"docs":{},"한":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"일":{"docs":{},"반":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},"단":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"두":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"반":{"docs":{},"대":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"이":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"므":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"기":{"docs":{},"때":{"docs":{},"문":{"docs":{},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}}}},"가":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}}},"를":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"있":{"docs":{},"고":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"로":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},"는":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"역":{"docs":{},"이":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}},"지":{"docs":{},"가":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}},"도":{"docs":{},"된":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"나":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"존":{"docs":{},"성":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}}}},"은":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.006825938566552901},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814}}},"이":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"하":{"docs":{},"지":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"된":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"해":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.015209125475285171},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"서":{"docs":{},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"례":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}}}}}}}}},"심":{"docs":{},"스":{"docs":{},"러":{"docs":{},"울":{"docs":{},"겁":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}}}},"한":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"이":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004545454545454545},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0037054191755442334},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0036815462494247586},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.007897334649555774},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0041928721174004195},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0045662100456621},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.007444168734491315},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.003875968992248062},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0028694404591104736},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.004273504273504274},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0045090180360721445},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00617828773168579},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005177514792899409},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004076878276062901},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.007792207792207792},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.016293279022403257},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.019762845849802372},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005681818181818182},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"곳":{"docs":{},"을":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}},"에":{"docs":{},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"슈":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"을":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"동":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"할":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"하":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}},"려":{"docs":{},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"시":{"docs":{},"키":{"docs":{},"세":{"docs":{},"요":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"여":{"docs":{},"기":{"docs":{},"서":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}},"했":{"docs":{},"음":{"docs":{},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"러":{"docs":{},"한":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0032213529682466636},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020086083213773313},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"름":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"도":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0028694404591104736},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00331858407079646},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.004273504273504274},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.004008016032064128},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004437869822485207},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.012219959266802444},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00353045013239188},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"인":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}},"어":{"docs":{},"야":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"지":{"docs":{},"만":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}},".":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}},"여":{"docs":{},"전":{"docs":{},"히":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"이":{"docs":{},"러":{"docs":{},"한":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}},"은":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"뿐":{"docs":{},"인":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}},"들":{"docs":{},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"\"":{"docs":{},"을":{"docs":{},"\"":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}},"전":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},"과":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"제":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.007069913589945012},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"것":{"docs":{},"뿐":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"다":{"docs":{},"음":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"들":{"docs":{},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002779064381658175},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"라":{"docs":{},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"미":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"상":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}},"인":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"하":{"docs":{},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"과":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"득":{"docs":{},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"때":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"런":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"렇":{"docs":{},"게":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"하":{"docs":{},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"유":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}},"가":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"를":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"점":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"해":{"docs":{},"함":{"docs":{},"으":{"docs":{},"로":{"docs":{},"써":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"하":{"docs":{},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}},"려":{"docs":{},"면":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"면":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"할":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"해":{"docs":{},"야":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"므":{"docs":{},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"후":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"번":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"에":{"docs":{},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"보":{"docs":{},"다":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"야":{"docs":{},"기":{"docs":{},"하":{"docs":{},"겠":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"인":{"docs":{},"스":{"docs":{},"턴":{"docs":{},"스":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"때":{"docs":{},"로":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"나":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"며":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"어":{"docs":{},"서":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"지":{"docs":{},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"며":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"루":{"docs":{},"어":{"docs":{},"지":{"docs":{},"면":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}},"로":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"들":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"을":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"터":{"docs":{},"러":{"docs":{},"블":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}},"레":{"docs":{},"이":{"docs":{},"터":{"docs":{},"와":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":5}}}}}}},"니":{"docs":{},"셜":{"docs":{},"라":{"docs":{},"이":{"docs":{},"저":{"docs":{},"를":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}},"용":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"한":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"하":{"docs":{},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"있":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},".":{"docs":{"./":{"ref":"./","tf":0.01818181818181818},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008417508417508417},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.006284367635506678},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.00909090909090909},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.006762468300929839},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.009726725335803613},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.005982512655315232},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.006910167818361303},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.005517241379310344},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.007686932215234102},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.006392694063926941},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.004591104734576757},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.011111111111111112},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.006268436578171091},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.006825938566552901},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.00751503006012024},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005917159763313609},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0034944670937682005},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.006418485237483954},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.013824884792626729}},"단":{"docs":{},"어":{"docs":{},"의":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}},"편":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"도":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}},"o":{"docs":{},"f":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"v":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"i":{"docs":{},"s":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}}},"a":{"docs":{},"r":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"경":{"docs":{},"우":{"docs":{},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}},"그":{"docs":{},"러":{"docs":{},"나":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"런":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"렇":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"게":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}},"들":{"docs":{},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"럼":{"docs":{},"에":{"docs":{},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"기":{"docs":{},"호":{"docs":{},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}},"본":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"다":{"docs":{},"음":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"과":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"소":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"시":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},"\"":{"docs":{},"와":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}}}},"먼":{"docs":{},"저":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"브":{"docs":{},"라":{"docs":{},"우":{"docs":{},"저":{"docs":{},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"제":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"러":{"docs":{},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"런":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"렇":{"docs":{},"게":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"하":{"docs":{},"면":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}},"전":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"것":{"docs":{},"은":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"페":{"docs":{},"이":{"docs":{},"지":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}},"가":{"docs":{},"능":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"또":{"docs":{},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"아":{"docs":{},"마":{"docs":{},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"래":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"여":{"docs":{},"기":{"docs":{},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"에":{"docs":{},"서":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},"예":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"전":{"docs":{},"형":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"사":{"docs":{},"용":{"docs":{},"자":{"docs":{},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}},"어":{"docs":{},"떤":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"떠":{"docs":{},"한":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},"일":{"docs":{},"반":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"a":{"docs":{},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}},"n":{"docs":{},"i":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}}}},"/":{"docs":{},"c":{"docs":{},"+":{"docs":{},"+":{"docs":{},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}},"변":{"docs":{},"수":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"최":{"docs":{},"선":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}}},"두":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"실":{"docs":{},"제":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"왜":{"docs":{},"냐":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"인":{"docs":{},"덱":{"docs":{},"싱":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"프":{"docs":{},"로":{"docs":{},"퍼":{"docs":{},"티":{"docs":{},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"e":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"6":{"docs":{},"로":{"docs":{},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"docs":{}}}}}}}}}}},"즉":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}}}},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"물":{"docs":{},"론":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}}}}}}},"제":{"docs":{},"네":{"docs":{},"릭":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"첫":{"docs":{},"번":{"docs":{},"째":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"문":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"자":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"열":{"docs":{},"거":{"docs":{},"형":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"의":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}},"원":{"docs":{},"본":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"타":{"docs":{},"입":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}},"(":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}},"스":{"docs":{},"크":{"docs":{},"립":{"docs":{},"트":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}}}}},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"o":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"m":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"l":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"각":{"docs":{},"각":{"docs":{},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"구":{"docs":{},"문":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"명":{"docs":{},"시":{"docs":{},"적":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"내":{"docs":{},"장":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},"보":{"docs":{},"낼":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},"목":{"docs":{},"록":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"컴":{"docs":{},"파":{"docs":{},"일":{"docs":{},"러":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"만":{"docs":{},"약":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"몇":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"비":{"docs":{},"슷":{"docs":{},"한":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"파":{"docs":{},"일":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"네":{"docs":{},"임":{"docs":{},"스":{"docs":{},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}}},"모":{"docs":{},"듈":{"docs":{},"은":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"따":{"docs":{},"라":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"외":{"docs":{},"부":{"docs":{},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"지":{"docs":{},"정":{"docs":{},"하":{"docs":{},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"한":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}},"결":{"docs":{},"과":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}},"데":{"docs":{},"코":{"docs":{},"레":{"docs":{},"이":{"docs":{},"터":{"docs":{},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}}}}},"메":{"docs":{},"서":{"docs":{},"드":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"접":{"docs":{},"근":{"docs":{},"제":{"docs":{},"어":{"docs":{},"자":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}},"나":{"docs":{},"중":{"docs":{},"에":{"docs":{},"는":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}},"마":{"docs":{},"찬":{"docs":{},"가":{"docs":{},"지":{"docs":{},"로":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}},"반":{"docs":{},"대":{"docs":{},"로":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"앞":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"►":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"자":{"docs":{},"세":{"docs":{},"한":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},")":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0033812341504649195},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0028694404591104736},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.008153756552125802},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"하":{"docs":{},"나":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"!":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"\"":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"(":{"docs":{},"병":{"docs":{},"합":{"docs":{},"되":{"docs":{},"지":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},"한":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"을":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"게":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"되":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.005050505050505051},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.006762468300929839},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0041417395306028535},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002758620689655172},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0041928721174004195},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0045662100456621},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020086083213773313},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.007478632478632479},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.004008016032064128},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00353045013239188},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.01278409090909091},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}},"지":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"를":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"어":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"도":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"마":{"docs":{},"찬":{"docs":{},"가":{"docs":{},"지":{"docs":{},"로":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}}}}},"서":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}}}}},"었":{"docs":{},"음":{"docs":{},"에":{"docs":{},"도":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}},"는":{"docs":{},"데":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"던":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}},"이":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"도":{"docs":{},"록":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"음":{"docs":{},")":{"docs":{},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"에":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"다":{"docs":{},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"\"":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"으":{"docs":{},"며":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"이":{"docs":{},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"(":{"docs":{},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"므":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"만":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"기":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"를":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"는":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"던":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"듯":{"docs":{},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"면":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"저":{"docs":{},"장":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"소":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}}}}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"한":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"할":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"된":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}},"전":{"docs":{},"문":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}},"적":{"docs":{},"이":{"docs":{},"거":{"docs":{},"나":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}}}}},"달":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"하":{"docs":{},"여":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"고":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"자":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814}}},"더":{"docs":{},"라":{"docs":{},"도":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"지":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"할":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"되":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}},"된":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"대":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"했":{"docs":{},"는":{"docs":{},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"해":{"docs":{},"야":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}}}},"송":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"용":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},")":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}}}},"이":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"으":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"인":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"형":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"환":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"통":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"인":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"혀":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"개":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"보":{"docs":{},"다":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"하":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}},"역":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"으":{"docs":{},"로":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"체":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"에":{"docs":{},"서":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"방":{"docs":{},"향":{"docs":{},"(":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}}}}},"략":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},"에":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"요":{"docs":{},"즘":{"docs":{},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}},"제":{"docs":{},"로":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}},"처":{"docs":{},"리":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006109979633401222}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"파":{"docs":{},"일":{"docs":{},"이":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}}}}},"주":{"docs":{},"로":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"하":{"docs":{},"는":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}}},"목":{"docs":{},"하":{"docs":{},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{},"이":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"와":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}}}}}}}},"세":{"docs":{},"요":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"일":{"docs":{},"단":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},"할":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}},"만":{"docs":{},"한":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}},"어":{"docs":{},"야":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"진":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"질":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"집":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"가":{"docs":{},"장":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}}},"지":{"docs":{},"면":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"의":{"docs":{},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}},"사":{"docs":{},"항":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.006988934187536401}},"이":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"하":{"docs":{},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"\"":{"docs":{},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}}},"제":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},"를":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"듯":{"docs":{},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"석":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"으":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"이":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"은":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"주":{"docs":{},"석":{"docs":{},"의":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}},"을":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}}},"장":{"docs":{},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"하":{"docs":{},"고":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"며":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},"문":{"docs":{},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"요":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"지":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"만":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"입":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"해":{"docs":{},"야":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}},"되":{"docs":{},"는":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},"식":{"docs":{},"과":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}},"이":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"원":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"되":{"docs":{},"지":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.045}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"여":{"docs":{},"기":{"docs":{},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"이":{"docs":{},"것":{"docs":{},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}},"다":{"docs":{},"음":{"docs":{},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}},"이":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"하":{"docs":{},"지":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"기":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"며":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"해":{"docs":{},"야":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}},"에":{"docs":{},"서":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"은":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"향":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"시":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"또":{"docs":{},"한":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"모":{"docs":{},"듈":{"docs":{},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"여":{"docs":{},"기":{"docs":{},"에":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"자":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":3.333333333333333}},"를":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006109979633401222},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"는":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.020366598778004074}}},"도":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"로":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"와":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"파":{"docs":{},"일":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}}},"정":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"되":{"docs":{},"지":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.005134788189987163},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"었":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"므":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"어":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}},"면":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.005852842809364548}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"따":{"docs":{},"라":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"한":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"다":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"했":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"하":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"려":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"고":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"면":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"기":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"여":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"세":{"docs":{},"요":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"면":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636}}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"자":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}},"(":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"와":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"된":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005681818181818182},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"해":{"docs":{},"야":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0035070140280561123}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}},"금":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"부":{"docs":{},"터":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"은":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"까":{"docs":{},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"루":{"docs":{},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"나":{"docs":{},"면":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"치":{"docs":{},"기":{"docs":{},"도":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"역":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"변":{"docs":{},"수":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"화":{"docs":{},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"적":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"점":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"우":{"docs":{},"지":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"진":{"docs":{},"행":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}},"할":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"되":{"docs":{},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"어":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"단":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"하":{"docs":{},"거":{"docs":{},"나":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"참":{"docs":{},"고":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}},"하":{"docs":{},"여":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}},"였":{"docs":{},"으":{"docs":{},"며":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}}},"조":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006109979633401222},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"서":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.00919732441471572},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.013824884792626729}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"네":{"docs":{},"임":{"docs":{},"스":{"docs":{},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{},"에":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}}},"확":{"docs":{},"대":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"고":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}},"기":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"며":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},")":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"할":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}},"해":{"docs":{},"야":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006109979633401222},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"이":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"되":{"docs":{},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}}}},"초":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"보":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}},"자":{"docs":{},"를":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},"기":{"docs":{},"화":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.005479452054794521}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"마":{"docs":{},"찬":{"docs":{},"가":{"docs":{},"지":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"상":{"docs":{},"수":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}},"할":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"해":{"docs":{},"야":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}},"된":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603}}},"만":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"되":{"docs":{},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"를":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"하":{"docs":{},"거":{"docs":{},"나":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"고":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"될":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"로":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"점":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"통":{"docs":{},"해":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"합":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":3.333333333333333}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"거":{"docs":{},"기":{"docs":{},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"이":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"과":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"하":{"docs":{},"도":{"docs":{},"록":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"할":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"되":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"해":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"했":{"docs":{},"는":{"docs":{},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}}}}},"찰":{"docs":{},"력":{"docs":{},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"페":{"docs":{},"이":{"docs":{},"지":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"를":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"가":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}}},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"와":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"의":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}}}}}},"품":{"docs":{},"질":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}},"의":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},"피":{"docs":{},"드":{"docs":{},"백":{"docs":{},"은":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}}},"할":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"해":{"docs":{},"야":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"하":{"docs":{},"려":{"docs":{},"면":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"고":{"docs":{},"자":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}},"필":{"docs":{},"요":{"docs":{},"했":{"docs":{},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"때":{"docs":{},"문":{"docs":{},"에":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}}}}}}}}},"하":{"docs":{},"지":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"다":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"한":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}},"또":{"docs":{},"한":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"b":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"은":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"기":{"docs":{},"본":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"다":{"docs":{},"음":{"docs":{},"과":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"매":{"docs":{},"개":{"docs":{},"변":{"docs":{},"수":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"여":{"docs":{},"기":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"도":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"없":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"때":{"docs":{},"도":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"드":{"docs":{},"가":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"인":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"수":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"적":{"docs":{},"인":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"으":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"터":{"docs":{},"링":{"docs":{},"할":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}},"하":{"docs":{},"며":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"자":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"기":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"나":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"씩":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"와":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"서":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"인":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"일":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"도":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"라":{"docs":{},"도":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"만":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"에":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}}},"게":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"듯":{"docs":{},"이":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"려":{"docs":{},"면":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"여":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"위":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0024679170779861796},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.003875968992248062},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005917159763313609},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"이":{"docs":{},"브":{"docs":{},"리":{"docs":{},"드":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"드":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"므":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"!":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},":":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},"도":{"docs":{},"록":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006109979633401222},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636}},"글":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}},"번":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"다":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"면":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"가":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"계":{"docs":{},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"쪽":{"docs":{},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"편":{"docs":{},"으":{"docs":{},"로":{"docs":{},"는":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"곳":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"정":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"할":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.005050505050505051},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.003943661971830986},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.006818181818181818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0033812341504649195},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0037054191755442334},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0034550839091806516},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.005590496156533892},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.002582496413199426},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705}},"당":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.003875968992248062},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00507185122569738},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"될":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"되":{"docs":{},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"어":{"docs":{},"야":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"하":{"docs":{},"거":{"docs":{},"나":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}}},"여":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"려":{"docs":{},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"이":{"docs":{},"것":{"docs":{},"은":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"예":{"docs":{},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}},"의":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"과":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"이":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.003875968992248062}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}},"에":{"docs":{},"서":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724}}}},"은":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"도":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"수":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"함":{"docs":{},"께":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004545454545454545},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"수":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0041685965724872626},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0050621260929590425},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":10.00919540229885},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.004891684136967156},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.01488833746898263},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.005426356589147287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00529567519858782},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0052417006406523005},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.006418485237483954},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004137931034482759},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.006289308176100629},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.003875968992248062},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002758620689655172},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0036781609195402297},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.005057471264367816},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.003218390804597701},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004659289458357601}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"라":{"docs":{},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"면":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"예":{"docs":{},"제":{"docs":{},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"이":{"docs":{},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"이":{"docs":{},"든":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"기":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"처":{"docs":{},"럼":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"형":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036}}},"만":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"거":{"docs":{},"나":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"나":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"을":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},"정":{"docs":{},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"해":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}},"주":{"docs":{},"시":{"docs":{},"면":{"docs":{"./":{"ref":"./","tf":0.01818181818181818}}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"당":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}},"되":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"줍":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}},"이":{"docs":{},"것":{"docs":{},"은":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}}},"야":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}},"할":{"docs":{},"까":{"docs":{},"요":{"docs":{},"?":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}},"결":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"책":{"docs":{},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"할":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"하":{"docs":{},"기":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"려":{"docs":{},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"고":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"지":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"해":{"docs":{},"야":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"만":{"docs":{},"약":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}}}}}}}},"제":{"docs":{},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"보":{"docs":{},"세":{"docs":{},"요":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},".":{"docs":{},".":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}},"체":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"석":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":5.008517034068136},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.005016722408026756},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"되":{"docs":{},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"으":{"docs":{},"며":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"된":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"다":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"될":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"그":{"docs":{},"러":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"자":{"docs":{},"세":{"docs":{},"한":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"하":{"docs":{},"기":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"위":{"docs":{},"해":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814}}},"려":{"docs":{},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"할":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},".":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}},"의":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"치":{"docs":{},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"향":{"docs":{},"후":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"상":{"docs":{},"된":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"홈":{"docs":{},"페":{"docs":{},"이":{"docs":{},"지":{"docs":{},"의":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}}}}},"확":{"docs":{},"인":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"할":{"docs":{"./":{"ref":"./","tf":0.00909090909090909},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}}}}},"m":{"docs":{},"s":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}},"기":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"거":{"docs":{},"나":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"해":{"docs":{},"보":{"docs":{},"세":{"docs":{},"요":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"야":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"한":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"되":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"장":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"자":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"만":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"해":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}},"야":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"하":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"면":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"여":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"거":{"docs":{},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"지":{"docs":{},"도":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"고":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"될":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"시":{"docs":{},"키":{"docs":{},"기":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"서":{"docs":{},"만":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"/":{"docs":{},"구":{"docs":{},"현":{"docs":{},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"된":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}},"보":{"docs":{},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"실":{"docs":{},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"하":{"docs":{},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"한":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"히":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}}},"대":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"를":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"에":{"docs":{},"서":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"와":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},"환":{"docs":{},"영":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.00909090909090909}}}}}}}},"경":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}},"내":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"\"":{"0":{"0":{"1":{"docs":{},"+":{"0":{"1":{"0":{"docs":{},"=":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{},".":{"1":{"9":{"docs":{},".":{"2":{"4":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}},"docs":{}},"docs":{}}},"docs":{},".":{"2":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"docs":{}}},"docs":{}},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}},"1":{"0":{"0":{"docs":{},"\"":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"1":{"docs":{},"\"":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}}}}},"docs":{},"억":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"2":{"3":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"docs":{}},"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702}},"\"":{"docs":{},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}}}}},"docs":{}}},"docs":{}},"\"":{"docs":{},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"+":{"2":{"docs":{},"*":{"3":{"3":{"docs":{},"/":{"1":{"1":{"docs":{},"=":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}}},"2":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}},"docs":{}}},"2":{"docs":{},".":{"0":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}}}},"docs":{}}},"docs":{}},"\"":{"docs":{},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"3":{"docs":{},".":{"9":{"docs":{},".":{"0":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}}}}},"docs":{}}},"docs":{}},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"4":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"5":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"docs":{}}},"docs":{}},"\"":{"docs":{},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"6":{"docs":{},"\"":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"7":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"8":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"9":{"8":{"0":{"5":{"2":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.021885521885521887},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0024679170779861796},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.015172413793103448},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008417508417508417},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0024679170779861796},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.004537205081669692}}},"\"":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"!":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"y":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}}}},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"w":{"docs":{},"d":{"docs":{},"y":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165}}}}}}},"u":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}}},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367}},"\"":{"docs":{},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}}},"s":{"docs":{},"x":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"o":{"docs":{},"n":{"docs":{},"!":{"docs":{},"*":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}},"m":{"docs":{},".":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"p":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"i":{"docs":{},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"k":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}},"a":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"b":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},";":{"docs":{},"문":{"docs":{},"을":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"r":{"docs":{},"e":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}},"n":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"z":{"docs":{},"i":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}}},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}}}}}},"h":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"i":{"docs":{},"n":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"r":{"docs":{},"\"":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}},")":{"docs":{},";":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}}}},"p":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"n":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"r":{"docs":{},"l":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}},"f":{"8":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"docs":{}}},"m":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},".":{"docs":{},"/":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"p":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"]":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}}},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},"\"":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}},"i":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"/":{"docs":{},"b":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}},"\"":{"docs":{},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"*":{"docs":{},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},"\"":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"x":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}},"\"":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}}},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"s":{"docs":{},"/":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}}},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}}}}}}}}}}}}}},"x":{"docs":{},"y":{"docs":{},"z":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"!":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.003687315634218289}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"x":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}},"\\":{"docs":{},"n":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},";":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"j":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"/":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"/":{"docs":{},"j":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{},"/":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"/":{"docs":{},"t":{"docs":{},"s":{"docs":{},"c":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"보":{"docs":{},"다":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"^":{"0":{"docs":{},".":{"6":{"docs":{},".":{"4":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"docs":{}}},"docs":{}}},"docs":{}},"a":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"2":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"/":{"docs":{},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"l":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}},"}":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}}},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436}}}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149}}}}}}}},"\"":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}},")":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}}},"d":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"와":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.009943181818181818}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}},"n":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436}}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}}}}}}},"i":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"\"":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}},";":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"y":{"docs":{},"a":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}},"r":{"docs":{},"l":{"docs":{},"f":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}},"v":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"]":{"docs":{},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"w":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}},"g":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408}}}}},"e":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}}},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}},"i":{"docs":{},"a":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},"]":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}}}}},"g":{"docs":{},"n":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"\"":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}}}}}},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}},"s":{"2":{"0":{"1":{"5":{"docs":{},"\"":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"6":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"7":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"docs":{}},"docs":{}},"docs":{}},"3":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}}},"5":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"6":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"/":{"docs":{},"\"":{"docs":{},"e":{"docs":{},"s":{"2":{"0":{"1":{"5":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"와":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"►":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"는":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"x":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005681818181818182}},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"에":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"]":{"docs":{},",":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}}}}}}}},"a":{"docs":{},"s":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.002582496413199426}}}},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005681818181818182}},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"과":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},"d":{"docs":{},"\"":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"\"":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}},"s":{"docs":{},"\"":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}}},"와":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"라":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"/":{"docs":{},"*":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}},"u":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}},"g":{"docs":{},"a":{"docs":{},"c":{"docs":{},"y":{"docs":{},"/":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"\"":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}}}}}}}}},"f":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"n":{"docs":{},"o":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"\"":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"\"":{"docs":{},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"j":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"/":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"/":{"docs":{},"j":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}}},"n":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"\"":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}},"w":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}}}}}}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002}}}}}}},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909}},"\"":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},";":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"와":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\"":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}}}}}}}}}}}}}}},"x":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{},"\"":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"o":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},";":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}}}}}}},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"만":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{},"\"":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"#":{"docs":{},"{":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"}":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}},"z":{"docs":{},"h":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"*":{"docs":{},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149}}}}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"}":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}}}}},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.003218390804597701}}}}}}},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}}}}}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}}}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}}},"m":{"docs":{},"u":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}},"c":{"docs":{},"t":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}}}}}},"t":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},":":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"d":{"docs":{},"k":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}},"_":{"docs":{},"t":{"docs":{},"s":{"docs":{},"d":{"docs":{},"k":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}}}}},"\"":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}},":":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"와":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}}}},"h":{"docs":{},"i":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}},"s":{"docs":{},"\"":{"docs":{},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005681818181818182}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"을":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"'":{"docs":{},"l":{"docs":{},"l":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"m":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}},"h":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}},"/":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}},"\"":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"\"":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"\"":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}}},"a":{"docs":{},"r":{"docs":{},"\"":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"]":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}},"i":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}},"z":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"s":{"docs":{},"e":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}}},"과":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}},"o":{"docs":{},"b":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}},"\"":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}},"y":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}}}}}}}}}}}},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"s":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"s":{"docs":{},"s":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}},"네":{"docs":{},"임":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"스":{"docs":{},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{},"\"":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"\"":{"docs":{},"외":{"docs":{},"부":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}},"h":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"\"":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}},"나":{"docs":{},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"문":{"docs":{},"자":{"docs":{},"열":{"docs":{},"일":{"docs":{},"수":{"docs":{},"도":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}},"\"":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"$":{"docs":{},"$":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875}}}}}},"k":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}},"y":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}},"결":{"docs":{},"함":{"docs":{},"\"":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"존":{"docs":{},"재":{"docs":{},"\"":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"것":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}}},"좋":{"docs":{},"아":{"docs":{},"요":{"docs":{},"\"":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"환":{"docs":{},"경":{"docs":{},"\"":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"구":{"docs":{},"조":{"docs":{},"적":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"대":{"docs":{},"상":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"덕":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"사":{"docs":{},"전":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},")":{"docs":{},"\"":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}}}}}}},"옵":{"docs":{},"션":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}},"인":{"docs":{},"덱":{"docs":{},"스":{"docs":{},"\"":{"docs":{},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"스":{"docs":{},"턴":{"docs":{},"스":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"회":{"docs":{},"피":{"docs":{},"하":{"docs":{},"는":{"docs":{},"\"":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986}}}},"상":{"docs":{},"황":{"docs":{},"적":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}},"숨":{"docs":{},"겨":{"docs":{},"진":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"직":{"docs":{},"렬":{"docs":{},"화":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{},"\"":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}}}}}}}}}}},"가":{"docs":{},"장":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"상":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}}}}},"다":{"docs":{},"른":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"\"":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837}}}},"타":{"docs":{},"당":{"docs":{},"\"":{"docs":{},"한":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"리":{"docs":{},"터":{"docs":{},"럴":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"싱":{"docs":{},"글":{"docs":{},"톤":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855}}}}}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}}}}}}}}}}},"*":{"docs":{},"!":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}}}}}},"\"":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"(":{"docs":{},"모":{"docs":{},"든":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}}},"+":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"=":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"모":{"docs":{},"듈":{"docs":{},"\"":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}},"발":{"docs":{},"견":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"최":{"docs":{},"상":{"docs":{},"위":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"내":{"docs":{},"부":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}}}}}}},"@":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}}}}}}}}}},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}},"很":{"docs":{},"高":{"docs":{},"兴":{"docs":{},"认":{"docs":{},"识":{"docs":{},"你":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}},"您":{"docs":{},"好":{"docs":{},"吗":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"메":{"docs":{},"인":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"배":{"docs":{},"포":{"docs":{},"\"":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"추":{"docs":{},"가":{"docs":{},"\"":{"docs":{},"하":{"docs":{},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"프":{"docs":{},"로":{"docs":{},"젝":{"docs":{},"트":{"docs":{},"\"":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"선":{"docs":{},"언":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},"\"":{"docs":{},"와":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}},"지":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948}}}},"!":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"*":{"docs":{},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}}}}}}}}}},"'":{"0":{"docs":{},"'":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"1":{"0":{"0":{"docs":{},"'":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"docs":{},"'":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"1":{"docs":{},"'":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"docs":{},"'":{"docs":{},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"2":{"docs":{},"'":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},"[":{"docs":{},"]":{"docs":{},"'":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}},"'":{"docs":{},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}},"l":{"docs":{},"l":{"docs":{},"'":{"docs":{},"일":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"2":{"docs":{},"/":{"docs":{},"b":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"2":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"docs":{}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}},"r":{"docs":{},"x":{"docs":{},"j":{"docs":{},"s":{"docs":{},"/":{"docs":{},"b":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"r":{"docs":{},"x":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{},"]":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"j":{"docs":{},"s":{"docs":{},"/":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"/":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},".":{"docs":{},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"x":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"에":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"'":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}}}}}}}}}}}}},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"'":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"e":{"docs":{},"w":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"'":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"'":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"'":{"docs":{},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284}}}}}}}}},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},"에":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"'":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"[":{"docs":{},"]":{"docs":{},"'":{"docs":{},"타":{"docs":{},"입":{"docs":{},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"'":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"'":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"/":{"docs":{},"*":{"docs":{},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"'":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"m":{"docs":{},"e":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"'":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"'":{"docs":{},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"'":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"m":{"docs":{},"'":{"docs":{},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"x":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"'":{"docs":{},"작":{"docs":{},"업":{"docs":{},"도":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"이":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"'":{"docs":{},"프":{"docs":{},"로":{"docs":{},"퍼":{"docs":{},"티":{"docs":{},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"'":{"docs":{},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}},"l":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"'":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}},"'":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"'":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"'":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}},"'":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}},"안":{"docs":{},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},"'":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"와":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"x":{"docs":{},"'":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}},".":{"docs":{},".":{"docs":{},"'":{"docs":{},",":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}}}}}},"/":{"docs":{},"#":{"docs":{},"{":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"}":{"docs":{},"/":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"'":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"docs":{}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"2":{"docs":{},"'":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"docs":{}}}}},"z":{"docs":{},"h":{"docs":{},"/":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"'":{"docs":{},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"'":{"docs":{},";":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}}}}}}},"a":{"docs":{},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}},"'":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"'":{"docs":{},"과":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}},"y":{"docs":{},"'":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}},"r":{"docs":{},"g":{"docs":{},"'":{"docs":{},"로":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"'":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"'":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"와":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"!":{"docs":{},"'":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"'":{"docs":{},".":{"docs":{},"과":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"2":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}},"docs":{}}}}}}},"2":{"docs":{},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"3":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"docs":{}}}}}}},"docs":{}}}}}},"l":{"docs":{},"y":{"docs":{},"'":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"'":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},".":{"docs":{},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}},"d":{"docs":{},"'":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},"'":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}}}}}}},"{":{"docs":{},"}":{"docs":{},"'":{"docs":{},"타":{"docs":{},"입":{"docs":{},"을":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"?":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"?":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"'":{"docs":{},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}},"'":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"'":{"docs":{},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"/":{"docs":{},"*":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"'":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"1":{"docs":{},"'":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"2":{"docs":{},"'":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"docs":{}}}}}}},"t":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"'":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"'":{"docs":{},"이":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}}},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"'":{"docs":{},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"'":{"docs":{},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}}}}}}}}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"'":{"docs":{},"과":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"으":{"docs":{},"로":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}},"e":{"docs":{},"'":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{},"e":{"docs":{},"'":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}},".":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"'":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"'":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"'":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}}}}}}},"x":{"docs":{},"'":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"와":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"'":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"f":{"docs":{},"'":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"y":{"docs":{},"'":{"docs":{},"에":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"m":{"docs":{},"'":{"docs":{},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"'":{"docs":{},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"b":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}}}},"!":{"docs":{},"=":{"docs":{},"=":{"docs":{},"'":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"버":{"docs":{},"려":{"docs":{},"지":{"docs":{},"는":{"docs":{},"'":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}},"호":{"docs":{},"환":{"docs":{},"성":{"docs":{},"'":{"docs":{},"을":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}},"\"":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"u":{"docs":{},"n":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"\"":{"docs":{},"'":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"$":{"docs":{},"{":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"}":{"docs":{},"'":{"docs":{},".":{"docs":{},"`":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"}":{"docs":{},"'":{"docs":{},"`":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"'":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"'":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}},"위":{"docs":{},"로":{"docs":{},"'":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"*":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064}}}},"네":{"docs":{},"임":{"docs":{},"스":{"docs":{},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}},"선":{"docs":{},"언":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"'":{"docs":{},"로":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}},"#":{"docs":{},"f":{"docs":{},"f":{"0":{"0":{"docs":{},"f":{"docs":{},"f":{"docs":{},"'":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}},"docs":{}},"docs":{}}}}},"(":{"0":{"docs":{},".":{"0":{"2":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"5":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"docs":{}},"1":{"3":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"docs":{}},"docs":{}}},"1":{"5":{"docs":{},")":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"docs":{},")":{"docs":{},"과":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"2":{"docs":{},")":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"4":{"docs":{},")":{"docs":{},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"7":{"docs":{},")":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"8":{"docs":{},")":{"docs":{},"과":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}}}},"i":{"docs":{},"c":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"s":{"docs":{},")":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}}}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"i":{"docs":{},"c":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}}}},"a":{"docs":{},"r":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"j":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"s":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}},"s":{"docs":{},"t":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"u":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}}},"d":{"docs":{},"e":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00353045013239188}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},"t":{"docs":{},"r":{"docs":{},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}},"i":{"docs":{},"n":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"o":{"docs":{},"f":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165}}}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"g":{"docs":{},"r":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}}}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}},"s":{"docs":{},"f":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},")":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}}}}}},"t":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}}}}}},"f":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},".":{"docs":{},"e":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},"n":{"docs":{},"o":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}},"s":{"docs":{},")":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"e":{"docs":{},"r":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"e":{"docs":{},"d":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}},"x":{"docs":{},"t":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}},"e":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"c":{"docs":{},"t":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},")":{"docs":{},"가":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},")":{"docs":{},"[":{"docs":{},"i":{"docs":{},"d":{"docs":{},"]":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"d":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}}}}}},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0051813471502590676}},"o":{"docs":{},"f":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408}},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}}}}},"o":{"docs":{},"o":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}}},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"c":{"docs":{},"e":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}},"h":{"docs":{},"e":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}},"i":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}},"s":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}}}}}}}}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"n":{"docs":{},"g":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"s":{"docs":{},"c":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.006284367635506678},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.015584415584415584},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.006191950464396285},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}},".":{"docs":{},".":{"docs":{},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}},"a":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"d":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},"d":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.006042296072507553},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"i":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"j":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"i":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}},"s":{"docs":{},"o":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"n":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}}}}}}}}}}}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946}}}},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}},"g":{"docs":{},"e":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"s":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}},"d":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"b":{"docs":{},"u":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"o":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"y":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}}},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}}}}}},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},")":{"docs":{},"[":{"docs":{},"i":{"docs":{},"d":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"n":{"docs":{},"g":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"으":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}},"u":{"docs":{},"b":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}},".":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}}}}}}}},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}},"f":{"docs":{},"c":{"docs":{},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"n":{"docs":{},"i":{"docs":{},"x":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"o":{"docs":{},"n":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}},"s":{"docs":{},"e":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"r":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},")":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"l":{"docs":{},"l":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"h":{"docs":{},"i":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"e":{"docs":{},"n":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"d":{"docs":{},"_":{"1":{"docs":{},"_":{"1":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"docs":{}}},"docs":{}},"u":{"docs":{},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00353045013239188}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}},"a":{"docs":{},"c":{"docs":{},")":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"s":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}}},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"r":{"docs":{},"p":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"h":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"s":{"docs":{},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},".":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{},"e":{"docs":{},".":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}}}}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837}}},"s":{"6":{"docs":{},")":{"docs":{},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"docs":{}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"r":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},",":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946}},"i":{"docs":{},"c":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}}},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"l":{"docs":{},"o":{"docs":{},"b":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"p":{"docs":{},"t":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}},"f":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},"x":{"8":{"6":{"docs":{},")":{"docs":{},"\\":{"docs":{},"m":{"docs":{},"s":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"\\":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},"\\":{"docs":{},"v":{"docs":{},"i":{"docs":{},"s":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{},"i":{"docs":{},"o":{"docs":{},"\\":{"docs":{},"v":{"docs":{},"$":{"docs":{},"(":{"docs":{},"v":{"docs":{},"i":{"docs":{},"s":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{},"i":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},"\\":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"\\":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"?":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"와":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}}}},"또":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}},"e":{"docs":{},"t":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.022222222222222223},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.00641025641025641},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"o":{"docs":{},"f":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"t":{"docs":{},"h":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"i":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"x":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"l":{"docs":{},"y":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"p":{"docs":{},"h":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"e":{"docs":{},"t":{"docs":{},")":{"docs":{},".":{"docs":{},"f":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},".":{"docs":{},"f":{"docs":{},"l":{"docs":{},"y":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"m":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}},"`":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"그":{"docs":{},"러":{"docs":{},"나":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"리":{"docs":{},"고":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"꺾":{"docs":{},"쇠":{"docs":{},"괄":{"docs":{},"호":{"docs":{},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}},"f":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"s":{"docs":{},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}},")":{"docs":{},"[":{"docs":{},"i":{"docs":{},"d":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}},"o":{"docs":{},"o":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}}},"v":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"a":{"docs":{},"r":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}},"l":{"docs":{},"u":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"e":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"i":{"docs":{},"d":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}},"{":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}}}}}},"최":{"docs":{},"소":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}},"w":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}},"y":{"docs":{},"b":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}},"r":{"docs":{},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},"기":{"docs":{},"본":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"값":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"다":{"docs":{},"른":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"예":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"y":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"이":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"것":{"docs":{},"들":{"docs":{},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"타":{"docs":{},"입":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"!":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"i":{"docs":{},"d":{"docs":{},")":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}}},"(":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"m":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}},")":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}},"글":{"docs":{},"로":{"docs":{},"벌":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"즉":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"모":{"docs":{},"듈":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"로":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"\"":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064}}}}}}},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"과":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}}}}}}}}}}},"주":{"docs":{},"어":{"docs":{},"진":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}},"병":{"docs":{},"합":{"docs":{},"되":{"docs":{},"지":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},"@":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}},"디":{"docs":{},"렉":{"docs":{},"토":{"docs":{},"리":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}}}},"공":{"docs":{},"통":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"윈":{"docs":{},"도":{"docs":{},"우":{"docs":{},")":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"유":{"docs":{},"닉":{"docs":{},"스":{"docs":{},")":{"docs":{},".":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"인":{"docs":{},"코":{"docs":{},"딩":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"특":{"docs":{},"정":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}},"맨":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}}}},"+":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.021885521885521887},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.005917159763313609},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0029615004935834156},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.019770114942528734},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.008527131782945736},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.004591104734576757},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0029498525073746312},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00617828773168579},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}}},"=":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"'":{"docs":{},"b":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"x":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},")":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},",":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"/":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"와":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0050704225352112674},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.003875968992248062},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00430416068866571},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.004056047197640118},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.006825938566552901},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00617828773168579},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.012953367875647668}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"c":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"s":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"]":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"o":{"docs":{},"f":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}},";":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}}}},"/":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},".":{"docs":{},".":{"docs":{},"/":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"@":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"@":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}},"e":{"docs":{},"/":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}},"#":{"docs":{},"{":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"}":{"docs":{},"/":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}}}}}},"z":{"docs":{},"h":{"docs":{},"/":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"에":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"@":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"만":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"d":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}},"의":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"의":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}},"e":{"docs":{},"s":{"6":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}}},"j":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.008985879332477536},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"s":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},".":{"docs":{},"p":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}},")":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"도":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"파":{"docs":{},"일":{"docs":{},"에":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}},"o":{"docs":{},"n":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"와":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"p":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}}}}}}},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.004713275726630008}}}}}}}}}}},"'":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"b":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"{":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},".":{"docs":{},"/":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}},"(":{"docs":{},"{":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}},"u":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}}}}}}},"\"":{"docs":{},"t":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"s":{"docs":{},")":{"docs":{},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.009084556254367574}}}}}}},"o":{"docs":{},"g":{"docs":{},"(":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},")":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}},"docs":{},"\"":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},")":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}}}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}}}}}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"5":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}},"docs":{}}}}}}}}},"a":{"docs":{},"p":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}}},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"h":{"docs":{},"파":{"docs":{},"일":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.003218390804597701},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"*":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.006825938566552901},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.021671826625386997}},"*":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.008985879332477536},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"!":{"docs":{},"로":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"/":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.010704225352112675},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.011363636363636364},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.016060862214708368},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.015284854099119963},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.005982512655315232},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.006910167818361303},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.014712643678160919},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.008385744234800839},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.01004566210045662},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.01627906976744186},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.011764705882352941},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.015209125475285171},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.018518518518518517},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00663716814159292},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.010683760683760684},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.01059135039717564},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.023668639053254437},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.023376623376623377},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.025673940949935817},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.007259528130671506},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.015479876160990712},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.011658031088082901},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00911854103343465}},"/":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.005341880341880342},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.03054989816700611},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.004537205081669692},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.01718213058419244}},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"그":{"docs":{},"래":{"docs":{},"도":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"\\":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"$":{"docs":{},"/":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}},"t":{"docs":{},"s":{"docs":{},"x":{"docs":{},"?":{"docs":{},"$":{"docs":{},"/":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}},"s":{"docs":{},"r":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"^":{"docs":{},"[":{"0":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}},"docs":{},"a":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"/":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"/":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"/":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{},"s":{"docs":{},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"j":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"/":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"j":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"/":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"j":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"/":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"j":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"/":{"docs":{},"a":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"t":{"docs":{},"s":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}}}}},"b":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}},"j":{"docs":{},"s":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"/":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"j":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"/":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"j":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.005050505050505051},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.014098690835850957},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.014139827179890024},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0033812341504649195},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002758620689655172},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.004651162790697674},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},")":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}},"=":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.018518518518518517},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.025923016496465043},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.013521126760563381},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0338123415046492},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.03242241778601204},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.02208927749654855},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.027640671273445213},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.02666666666666667},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.009783368273934312},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.023744292237442923},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.01488833746898263},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.017054263565891473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.019799139167862266},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.034220532319391636},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.025925925925925925},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.022123893805309734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.023504273504273504},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0073964497041420114},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.015142690739662202},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.033766233766233764},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.021822849807445442},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.017241379310344827},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.017057569296375266},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.015544041450777202},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0364741641337386}},"=":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00353045013239188}},"=":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.003443328550932568},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.004424778761061947},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.004008016032064128}}}}}}}}},">":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.010852713178294573},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0022123893805309734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.008136094674556213},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.03116883116883117},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.01393188854489164}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}},">":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.003006012024048096},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}},">":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},">":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"=":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"[":{"0":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"1":{"0":{"docs":{},":":{"3":{"4":{"docs":{},":":{"2":{"0":{"docs":{},"]":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}},"1":{"docs":{},"]":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}},"docs":{}},"docs":{}}},"5":{"docs":{},":":{"2":{"2":{"docs":{},"]":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"4":{"docs":{},"]":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.011111111111111112},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}},"]":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"2":{"docs":{},"]":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"3":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"4":{"docs":{},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}},"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005681818181818182},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"\"":{"0":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"docs":{},"e":{"docs":{},"s":{"2":{"0":{"1":{"5":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}}}}},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"j":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"/":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"/":{"docs":{},"j":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}}}},"*":{"docs":{},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}},"'":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"'":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"2":{"docs":{},"/":{"docs":{},"b":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"2":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"'":{"docs":{},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"*":{"docs":{},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}}}}}}}}}},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"'":{"docs":{},"]":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"'":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{},"]":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"'":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}},"e":{"docs":{},"s":{"2":{"0":{"1":{"5":{"docs":{},"'":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"]":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},"를":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"y":{"docs":{},"m":{"docs":{},"]":{"docs":{},":":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"]":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875}}},"]":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"e":{"docs":{},"w":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.007444168734491315}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}}}}}}}},"p":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.002582496413199426}},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"]":{"docs":{},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}}}}},"x":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}}},"{":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"u":{"docs":{},"p":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}}}}}}}}}}}},"k":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"e":{"docs":{},"y":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{},"{":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}}},"e":{"docs":{},"d":{"docs":{},"되":{"docs":{},"어":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}}}},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.010070493454179255}},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"y":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}},"=":{"docs":{},">":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}}}}},"가":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}},"[":{"docs":{},"]":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"에":{"docs":{},"서":{"docs":{},"와":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135}}},"을":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}},"만":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"a":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.007897334649555774},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00529567519858782}},"a":{"docs":{},"l":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}},"g":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}},"과":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078}}},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"부":{"docs":{},"터":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436}}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"[":{"docs":{},"]":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.007444168734491315}}}},")":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"m":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"l":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}}}}}}},"의":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"d":{"docs":{},"x":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"p":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}},"s":{"docs":{},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}}}}}}}}},"i":{"docs":{},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}}}}}}}}}}}},"`":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"l":{"docs":{},"i":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"c":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}},"y":{"docs":{},"m":{"docs":{},"i":{"docs":{},"x":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}}}}}}}}}}}}},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}},"c":{"docs":{},"h":{"docs":{},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}},"i":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}},"r":{"docs":{},"g":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.005134788189987163}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.006191950464396285}},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"[":{"0":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}},"1":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}},"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"]":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}}}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},".":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.009783368273934312}}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"r":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}},"a":{"docs":{},"y":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"(":{"5":{"2":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}}}},"docs":{}},"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}},")":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}},"#":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"에":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}}}}}}}}}}}}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"o":{"docs":{},"w":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}},"e":{"docs":{},"a":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474}}},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}}}}},"도":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"s":{"docs":{},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},"n":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"x":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"p":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":5.008056394763344}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}},".":{"docs":{},"위":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"t":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}},"d":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0051813471502590676}},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"\"":{"docs":{},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}},"d":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.003629764065335753},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.006476683937823834}},"(":{"docs":{},"x":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"z":{"docs":{},"(":{"docs":{},"x":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"i":{"docs":{},"t":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"i":{"docs":{},"s":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},"u":{"docs":{},"n":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"s":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}},"j":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"s":{"docs":{},"에":{"docs":{},"만":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"와":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165}},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.003218390804597701}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},".":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}}}}}}}}},"'":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}},"i":{"docs":{},"a":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}},"s":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"s":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}},"도":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"와":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"b":{"docs":{},"u":{"docs":{},"m":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}},".":{"docs":{},"a":{"docs":{},"l":{"docs":{},"b":{"docs":{},"u":{"docs":{},"m":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986}},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}}}},"m":{"docs":{},"d":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.008146639511201629}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"t":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}}},"모":{"docs":{},"듈":{"docs":{},"은":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}},",":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"b":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875}}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735}}}}}}}},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}},"a":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"g":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"e":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{},"]":{"docs":{},"처":{"docs":{},"럼":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}}}}}}},"?":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"n":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}}}}},"+":{"docs":{},"+":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0037054191755442334},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.006476683937823834}},"\"":{"docs":{},"\"":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},"{":{"docs":{},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"와":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"[":{"1":{"0":{"docs":{},"]":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"docs":{}},"docs":{}},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0034550839091806516}},"으":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}},"o":{"docs":{},"v":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}},"c":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}},"p":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}},"i":{"docs":{},"d":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"a":{"docs":{},"t":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.023376623376623377}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}}}}}}}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}}},":":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}}}}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}}}}}}},"u":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}},"g":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}}}}}}},")":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}}}},".":{"docs":{},"a":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}},"b":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}},".":{"docs":{},"c":{"docs":{},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}},"y":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}}},"t":{"docs":{},"s":{"docs":{},"가":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"에":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}},"c":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.025906735751295335}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.005982512655315232},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.01332675222112537},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.004891684136967156},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0022955523672883787},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.008547008547008548},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.006825938566552901},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00706090026478376},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004437869822485207},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0064065230052417},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.015584415584415584},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.019189765458422176},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.012953367875647668}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/Templates.html":{"ref":"pages/declaration files/Templates.html","tf":0.07692307692307693}}}}}},")":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}},"i":{"docs":{},"c":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}},"o":{"docs":{},"u":{"docs":{},"d":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"n":{"docs":{},"e":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},".":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"p":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00706090026478376}}}}}}}}}},"r":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00353045013239188}}}}},"c":{"docs":{},"k":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0036815462494247586}},"e":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"라":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036}}}}}}}}}}}}}},"o":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"d":{"docs":{},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.007259528130671506},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.017057569296375266},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"나":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"\"":{"docs":{},"]":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}},",":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002779064381658175},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.005479452054794521},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0025811209439528023},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.004273504273504274},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"o":{"docs":{},"r":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004}},"(":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"h":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474}}}},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}}}}}}}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0024679170779861796},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"u":{"docs":{},"m":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0029615004935834156}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"x":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}}}},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}}}}}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"변":{"docs":{},"수":{"docs":{},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},")":{"docs":{},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603}}}}},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"(":{"docs":{},"`":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"$":{"docs":{},"{":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"}":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"\"":{"docs":{},"$":{"docs":{},"{":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}},"s":{"docs":{},"}":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"'":{"docs":{},"$":{"docs":{},"{":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}},"s":{"docs":{},"a":{"docs":{},"y":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}}}}}}}},"x":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"[":{"0":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},"docs":{}}}}}}}}}}},"1":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},"docs":{}}}}}}}}}}},"5":{"docs":{},"]":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}},"docs":{}},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}}}}}}}}},"\"":{"docs":{},"o":{"docs":{},"h":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"b":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"h":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}},"g":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}}},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"s":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}}}}}}},"오":{"docs":{},"류":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}}},"h":{"docs":{},"a":{"docs":{},"l":{"docs":{},"f":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{},"e":{"docs":{},".":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"x":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167}}}}}}}},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}}}}}}}}}}}}}}}}},"'":{"docs":{},"w":{"docs":{},"o":{"docs":{},"o":{"docs":{},"f":{"docs":{},"!":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"!":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"!":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}},"2":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}},"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"1":{"docs":{},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"{":{"docs":{},"x":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"2":{"docs":{},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"{":{"docs":{},"x":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}}}},"a":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0034940600978336828}}}}}}}}}}}}},".":{"docs":{},"x":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"x":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}}}}}},")":{"docs":{},";":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"[":{"docs":{},"s":{"docs":{},"y":{"docs":{},"m":{"docs":{},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"e":{"docs":{},"w":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}}}}}}}},"y":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},"d":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"p":{"docs":{},"t":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":10}}}}}},"i":{"docs":{},"d":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}},"e":{"docs":{},"(":{"docs":{},"i":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}}}}}}}}}}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}}}}},"s":{"docs":{},"/":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004}}},"s":{"docs":{},"\"":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"n":{"docs":{},"i":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}}}}},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.007772020725388601}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"x":{"docs":{},"t":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}},"s":{"docs":{},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}}},"?":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"e":{"docs":{},"를":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.005134788189987163}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}},"a":{"docs":{},"t":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}},"j":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148}},"s":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"모":{"docs":{},"듈":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},")":{"docs":{},"작":{"docs":{},"은":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.007772020725388601},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}}}}}}},"e":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},"r":{"docs":{},"e":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":5.00503524672709},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}}},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.006191950464396285}}}}}}}}},"p":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0076077768385460695},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0041417395306028535},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391}}}}}}},"r":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391}}}},"[":{"2":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"docs":{}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}},"?":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.006396588486140725}}}},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}},"u":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}}}}}},"l":{"docs":{},"a":{"docs":{},"p":{"docs":{},"s":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"e":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},"#":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"c":{"docs":{},"h":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},")":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}}},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}},"s":{"docs":{},"k":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.003443328550932568},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"e":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}}},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}}}}}}}}},"l":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.007259528130671506},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.021671826625386997}},"s":{"docs":{},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}},".":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}},"s":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},".":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}},"e":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.006436781609195402}}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}},"s":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149}}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}},"와":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"o":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}},"e":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}},"d":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909}},"n":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"을":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036}}},"\"":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}},"j":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"s":{"docs":{},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}}}}}}},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036}}}}}}}},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}}}}}},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148}}}},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}},"o":{"docs":{},"o":{"docs":{},"s":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},"\\":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}},"(":{"1":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"docs":{}},"docs":{},")":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},")":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"y":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},"e":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}},"a":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"b":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}}}}},"d":{"docs":{},";":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},"x":{"docs":{},";":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.003629764065335753},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.008528784648187633},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.011658031088082901}},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"(":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}}}}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}}}}}}},"{":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474}}}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"에":{"docs":{},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}},"(":{"docs":{},"c":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"e":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"l":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},".":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"z":{"docs":{},"o":{"docs":{},"o":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0088261253309797}}}}}}}}}}},"와":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}}}}}}}}},"l":{"docs":{},"f":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}},"[":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},"n":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"s":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"z":{"docs":{},"e":{"docs":{},"c":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"e":{"1":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}}},"2":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"의":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135}},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}},"u":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}},"`":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}}}}}}},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}},",":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}},";":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},"d":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}},"g":{"docs":{},"e":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"y":{"docs":{},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}},"에":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.003948667324777887}},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}}}}}},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}},".":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}}}}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"라":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"에":{"docs":{},"게":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"을":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"[":{"1":{"docs":{},"]":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"docs":{}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"을":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"n":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}},"y":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},".":{"docs":{},"t":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}},"i":{"docs":{},"r":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"e":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}},"d":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}},"u":{"docs":{},"m":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00422654268808115},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.021004566210045664},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"s":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0045662100456621},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"에":{"docs":{},"서":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}}},"e":{"docs":{},"r":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}}}}},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}}}}},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"v":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"s":{"2":{"0":{"1":{"5":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003927729772191673},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"서":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"도":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"인":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"/":{"docs":{},"e":{"docs":{},"s":{"6":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"docs":{}}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"x":{"docs":{},"i":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},".":{"docs":{},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}}}}}}}},"6":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}}}},"7":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},".":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"3":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},")":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}},"를":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"와":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}},",":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"5":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.011111111111111112},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"보":{"docs":{},"다":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}}}},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},",":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"6":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0054446460980036296},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},")":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"7":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.009074410163339383},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":10.004264392324094},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"e":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.008166969147005444},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.012953367875647668},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986}}},";":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}},":":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}},"c":{"docs":{},"t":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"l":{"docs":{},"i":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}}},"p":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004545454545454545},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.028392330383480827},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.01282051282051282},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.010238907849829351},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.01500441306266549},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.003629764065335753},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.018134715025906734}},")":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}}},"c":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"_":{"1":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"docs":{}},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"도":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"된":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"만":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"인":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"하":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"되":{"docs":{},"지":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"s":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"s":{"docs":{},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}}}},"은":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"따":{"docs":{},"라":{"docs":{},"서":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"[":{"1":{"docs":{},"]":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"docs":{}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"\"":{"docs":{},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}}},"d":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0032213529682466636},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.005134788189987163},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.006396588486140725},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"s":{"docs":{},"의":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"에":{"docs":{},"서":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},")":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"를":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"(":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"r":{"docs":{},"n":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"a":{"docs":{},"n":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}},"s":{"docs":{},"s":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"e":{"docs":{},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"와":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.004537205081669692},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0035070140280561123}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}},"e":{"docs":{},"p":{"docs":{},"h":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.007444168734491315}}}}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}},"s":{"docs":{},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},"e":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}},"?":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.006476683937823834}}}}}}}}},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"2":{"0":{"1":{"5":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}},"3":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"5":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}}}},"h":{"docs":{},"o":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}},"s":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"i":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.003629764065335753}},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}}},".":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"e":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603}}}}},"x":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"y":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"g":{"docs":{},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"e":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}}},":":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},"s":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}}}},"f":{"1":{"2":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"docs":{}},"5":{"docs":{},"키":{"docs":{},"를":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"i":{"docs":{},"l":{"docs":{},"e":{"1":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"2":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"3":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.004008016032064128},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.008166969147005444},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.020618556701030927},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.010309278350515464}}},"]":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}}}}},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.006191950464396285},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002758620689655172}},"e":{"docs":{},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.006734006734006734}}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}},"]":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"와":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}},"d":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986}}},"e":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}},"s":{"docs":{},"h":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"라":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}},"e":{"docs":{},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"i":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008417508417508417},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.006042296072507553},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.009426551453260016},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0050704225352112674},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0033812341504649195},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.009726725335803613},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0032213529682466636},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.008735632183908045},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.011879804332634521},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.010043041606886656},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.004424778761061947},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00617828773168579},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005917159763313609},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.011648223645894},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006109979633401222},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.005134788189987163},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.008166969147005444},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.03411513859275053},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.034055727554179564},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"(":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}},"r":{"docs":{},"c":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"x":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},":":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}}}}}}}},"y":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"_":{"1":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"docs":{}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}},"s":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"만":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Templates.html":{"ref":"pages/declaration files/Templates.html","tf":0.07692307692307693}},"s":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},":":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}}}},"s":{"docs":{},"s":{"docs":{},".":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"a":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"(":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"%":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}}}}}}}}}}}},"루":{"docs":{},"프":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},".":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408}},"은":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408}}}}},"o":{"docs":{},"f":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.018518518518518517}},"는":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.011111111111111112}}},"와":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},"c":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.009067357512953367},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"!":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"x":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},".":{"docs":{},"d":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226}}}}}}}}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"a":{"docs":{},";":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}}}}}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"d":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002779064381658175}}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"?":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}},"라":{"docs":{},"고":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"t":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148}},"e":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"]":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"n":{"docs":{},"d":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"2":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"docs":{}}}}}}},"2":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"3":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"docs":{}}}}}}},"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}}}}}}}}},"n":{"docs":{},"k":{"docs":{},"w":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"/":{"docs":{},"d":{"docs":{},"u":{"docs":{},"o":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}},"t":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}}},"w":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}},"l":{"docs":{},"s":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.039297658862876256},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"e":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.015584415584415584},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},")":{"docs":{},"함":{"docs":{},"수":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},",":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},"]":{"docs":{},";":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}}}}}}}}},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"r":{"docs":{},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}},"q":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}},"v":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}},"i":{"docs":{},"t":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}}}},"(":{"1":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}}},"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}},"[":{"1":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}}}}}}}}},"n":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}},"x":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"{":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167}},"}":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}},"g":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{},")":{"docs":{},"와":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"함":{"docs":{},"수":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"에":{"docs":{},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"라":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"m":{"docs":{},"y":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}}}}}}},"x":{"docs":{},".":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"f":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}}}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.020123839009287926}}}}}},"와":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"s":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},"f":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},",":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.010660980810234541}},"e":{"docs":{},"r":{"1":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"2":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.006734006734006734},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.006416584402764067},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004076878276062901},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.017057569296375266}},"(":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.005050505050505051}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008417508417508417}}}}}}}},"\"":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078}}},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367}}}}}},"j":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367}}},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.005050505050505051}},"s":{"docs":{},"파":{"docs":{},"일":{"docs":{},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0024679170779861796}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}}}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"라":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"라":{"docs":{},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"(":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002}}},"n":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"e":{"docs":{},"w":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}},"y":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"@":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}},"g":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},"e":{"docs":{},"t":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}},"{":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.008528784648187633}}},"\"":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},".":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}}}}}}},"k":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"e":{"docs":{},")":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},"e":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},")":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}}}}}}}},"n":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869}}}}}},"i":{"docs":{},"d":{"1":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"2":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"(":{"1":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"docs":{}}},"5":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"docs":{}}},"docs":{}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"y":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00911854103343465}},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"{":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"n":{"docs":{},"p":{"docs":{},"m":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"g":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"s":{"docs":{},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}},"와":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},":":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148}}}}}}}}}},"과":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"x":{"docs":{},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}}}}}}}}},"라":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"에":{"docs":{},"서":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"(":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"(":{"4":{"3":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}},"docs":{}},"docs":{},"\"":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}},"n":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}},"s":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.007739938080495356},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}},"d":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"2":{"docs":{},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"3":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"docs":{}}}}}}},"docs":{}}}}}}}}}}},"l":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},"\"":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"f":{"docs":{},"n":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0034940600978336828}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}}}}}}}}}},"s":{"docs":{},")":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}}}}}}}},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.006042296072507553},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0204241948153967},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0121580547112462}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},".":{"docs":{},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"s":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"/":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"/":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}}}}}}}}}},"\"":{"docs":{},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}}}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"s":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"은":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"e":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}}}}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},")":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"s":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}}},"라":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"(":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}},"함":{"docs":{},"수":{"docs":{},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"b":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636}},"a":{"docs":{},"l":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.03720508166969147},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.01279317697228145},"pages/declaration files/Templates.html":{"ref":"pages/declaration files/Templates.html","tf":0.15384615384615385},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Templates.html":{"ref":"pages/declaration files/Templates.html","tf":0.07692307692307693}}}}}}}}}}},")":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{},"은":{"docs":{},"(":{"docs":{},"는":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}},"을":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"n":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}},"o":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"o":{"docs":{},"d":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},".":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"{":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"(":{"docs":{},"{":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0032213529682466636},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.00641025641025641},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}},"s":{"docs":{},"와":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"를":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.005681818181818182},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.021755162241887907},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.008532423208191127},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.011022044088176353},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00353045013239188},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.012704174228675136},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.011658031088082901},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"서":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"s":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}}},"(":{"docs":{},"별":{"docs":{},"칭":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"서":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"로":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.003006012024048096}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.003006012024048096}}},"하":{"docs":{},"거":{"docs":{},"나":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"(":{"docs":{},"예":{"docs":{},":":{"docs":{},"'":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"'":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}}}}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}}},"된":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"/":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"의":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}},"문":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}},")":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148}}}}}},"a":{"docs":{},"g":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}},"i":{"docs":{},"n":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0054988216810683424},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.02127659574468085},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"l":{"docs":{},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"n":{"docs":{},"c":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}},"e":{"docs":{},"o":{"docs":{},"f":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}},"t":{"docs":{},"i":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}}},"t":{"3":{"2":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}}}},"docs":{}},"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.01058444546709618},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.005426356589147287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.004591104734576757},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.00641025641025641},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.01235657546337158},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.009615384615384616},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.01279317697228145},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.009287925696594427},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.015544041450777202}},"e":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"s":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"d":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"j":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"을":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"파":{"docs":{},"일":{"docs":{},"을":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}},"t":{"docs":{},"s":{"docs":{},"x":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"가":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"j":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"s":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},")":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"s":{"docs":{},"와":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"e":{"docs":{},"r":{"docs":{},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}}}}}},"i":{"docs":{},"c":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"i":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}}}}}},"o":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"에":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"[":{"0":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"1":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"docs":{}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}},"a":{"docs":{},"s":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}},"d":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"o":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135}}}}}}}}}}},"v":{"docs":{},"o":{"docs":{},"c":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"k":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"[":{"1":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}},"docs":{}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"g":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}}},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"(":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"로":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}}}},"'":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}},":":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"'":{"docs":{},"l":{"docs":{},"l":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"가":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}}},"문":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"s":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.01038961038961039}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"x":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"'":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"x":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00331858407079646},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.009615384615384616}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.01038961038961039}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"e":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"docs":{},"x":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}}}}}}},":":{"docs":{},"\"":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}},"o":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}},"i":{"docs":{},"f":{"docs":{},"e":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875}}},"와":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.007686932215234102},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.006289308176100629}}}}}}},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0034940600978336828}}}}},"f":{"docs":{},"i":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.009981851179673321}},"e":{"docs":{},"r":{"docs":{},"!":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"에":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"a":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"를":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"g":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"d":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}}}}}},"v":{"docs":{},"o":{"docs":{},"g":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"/":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}},"e":{"docs":{},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.006734006734006734},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},";":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149}}},"?":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"e":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}},"y":{"docs":{},"e":{"docs":{},"g":{"docs":{},"g":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}}}}}},"r":{"docs":{},"g":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}},"i":{"docs":{},"b":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"s":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"s":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"와":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},",":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":5.048094373865699},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}}}},"y":{"docs":{},"!":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},"'":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.004537205081669692},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}}},"가":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"n":{"docs":{},"k":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"e":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}},"s":{"docs":{},"t":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869}}},"[":{"1":{"docs":{},"]":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"docs":{}},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496}}}}}}}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}}}}}}}}}}}},")":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408}}},"s":{"docs":{},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}},"o":{"docs":{},"n":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}},"v":{"docs":{},"e":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"e":{"docs":{},"r":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0054446460980036296},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"\"":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"'":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"s":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"가":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}}},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},")":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"o":{"docs":{},"p":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"k":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.004537205081669692},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}},"g":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"3":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0034940600978336828}}}}}},"{":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}},"e":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"(":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165}}}}}},"n":{"docs":{},"g":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}}},"e":{"docs":{},"t":{"docs":{},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"과":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}},".":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}}}}}}}}}},"와":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}}}}}},"'":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004}}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}},"g":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"a":{"docs":{},"l":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"f":{"docs":{},"t":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0054446460980036296}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"a":{"docs":{},"d":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"f":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},"e":{"docs":{},"w":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.011352418558736426},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0034940600978336828},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.01488833746898263},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.002582496413199426},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.007005899705014749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.007478632478632479},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.007259528130671506},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"1":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"\"":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"2":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}},":":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00507185122569738},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"x":{"docs":{},"t":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"e":{"docs":{},"d":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.020618556701030927}},",":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}}},"s":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}}}}}}},"p":{"docs":{},"m":{"3":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.007855459544383346},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.007954545454545454},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.013745704467353952},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.02097902097902098},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0182370820668693},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"과":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.010309278350515464},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}},":":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}},",":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"u":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00911854103343465},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}},"과":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"를":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"에":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}},"l":{"docs":{},"l":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00422654268808115},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020086083213773313},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}},"과":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"]":{"docs":{},";":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"'":{"docs":{},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}},"일":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"s":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}},"m":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.006762468300929839},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004137931034482759},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0034940600978336828},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0031563845050215206},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.010660980810234541},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"(":{"docs":{},"이":{"docs":{},")":{"docs":{},"거":{"docs":{},"나":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002758620689655172},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.007739938080495356}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.005982512655315232},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0028694404591104736},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00441306266548985},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.006396588486140725},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.01238390092879257},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.010362694300518135}},"}":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"[":{"docs":{},"]":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}},")":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}},"[":{"docs":{},"]":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"'":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"]":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}}}},"와":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0036815462494247586},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0036781609195402297},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020086083213773313},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.006191950464396285}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"o":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}}}}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"이":{"docs":{},"거":{"docs":{},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"인":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"s":{"docs":{},")":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}},".":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}}}}}}}}}},"는":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}},"|":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}}}}}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}}}}},"s":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"e":{"docs":{},"r":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"i":{"docs":{},"c":{"docs":{},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}}}},"e":{"docs":{},"g":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020086083213773313},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.00641025641025641},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.010362694300518135},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986}},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.005923000987166831},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.003875968992248062},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0022955523672883787},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"과":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"라":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"o":{"docs":{},"f":{"docs":{},"a":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}}}},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}},"d":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}}}}},"!":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"docs":{}}}}}}}}}},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"docs":{}}}}}}}}},"?":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"e":{"docs":{},"r":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"s":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.01282051282051282},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005177514792899409},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.01279317697228145},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.031088082901554404}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"은":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}}}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}}},"n":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}},"e":{"docs":{},".":{"docs":{},"이":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},".":{"docs":{},"j":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.00501002004008016},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148}},"s":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"에":{"docs":{},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"보":{"docs":{},"다":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"\"":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},"/":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"j":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"s":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"e":{"docs":{},"s":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"라":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"/":{"docs":{},"@":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}}}}}}}}}}}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"!":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"\"":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"y":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},":":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}}}}}},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"s":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"s":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}},"e":{"docs":{},".":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}}}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}}}}}}},"o":{"docs":{},"k":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"e":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"y":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}}}}},":":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"c":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},"h":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}},"n":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0035070140280561123},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135}},"e":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"가":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"를":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}},"w":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":5.023041474654378}},"e":{"docs":{},"s":{"docs":{},"는":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}}},"o":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"o":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"p":{"docs":{},"s":{"docs":{},"!":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"1":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"2":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.006396588486140725},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.01238390092879257},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}}}},"v":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}}}}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"?":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}},"s":{"docs":{},",":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}}}},"b":{"docs":{},"j":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.008528784648187633},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"보":{"docs":{},"다":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"\"":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"s":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}},"x":{"docs":{},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"b":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}}},"[":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},"]":{"docs":{},"으":{"docs":{},"로":{"docs":{},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00529567519858782}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}},"에":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}}}}}}}},"t":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"s":{"docs":{},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},"'":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},"을":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"과":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"로":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},":":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436}},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}},"l":{"docs":{},"d":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}}}},".":{"docs":{},"a":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"와":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"b":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"에":{"docs":{},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"x":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167}}},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}},"g":{"docs":{},"a":{"docs":{},"n":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.006396588486140725},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}},"n":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0054446460980036296},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}},"c":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"b":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}},",":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"y":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.018575851393188854},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"s":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},",":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135}}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}},".":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}}}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"[":{"docs":{},"n":{"docs":{},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"]":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"k":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.018575851393188854},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0051813471502590676}}},"f":{"docs":{},"f":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008417508417508417},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.007855459544383346},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.006021306160259379},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0032213529682466636},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.011954022988505748},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.013277428371767994},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.01291248206599713},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.006268436578171091},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.00641025641025641},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00617828773168579},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005177514792899409},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0110658124635993},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.008528784648187633},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.01238390092879257},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0054446460980036296},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}},"t":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{},"y":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.004713275726630008}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}}}}},"\"":{"docs":{},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}},"t":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},"문":{"docs":{},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},";":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}},"/":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}}},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}},"a":{"docs":{},"g":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}}},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}},"d":{"docs":{},"u":{"docs":{},"o":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"[":{"docs":{},"\"":{"docs":{},".":{"docs":{},"/":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"s":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}},"j":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"m":{"docs":{},"d":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},".":{"docs":{},"j":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}},"라":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}},"이":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}},"(":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"s":{"docs":{},"t":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"o":{"docs":{},"r":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"f":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}}}}}}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"1":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149}}},"2":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149}}},"3":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149}}},"4":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"[":{"docs":{},"k":{"docs":{},"]":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}},"s":{"docs":{},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}},"e":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},"u":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}}}}}},"s":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"e":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},".":{"docs":{},"y":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.013636363636363636},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005177514792899409},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"!":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"\"":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}}}}}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"와":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036}}},"의":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"에":{"docs":{},"서":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}},"d":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"타":{"docs":{},"입":{"docs":{},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}}}}}}}}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"와":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"i":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.003948667324777887},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284}}}}}},"y":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"l":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"l":{"docs":{},"i":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},"s":{"docs":{},".":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}}},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0036982248520710057}}}}}},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}},"d":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"e":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"와":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}}}}}}},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"}":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.007772020725388601}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004659289458357601}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},":":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"(":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.00501002004008016}},"a":{"docs":{},"t":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}},"u":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.008528784648187633}}}}}}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}},"c":{"1":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702}}},"docs":{}},"u":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"n":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"e":{"docs":{},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}},"l":{"docs":{},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}},"s":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"o":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"5":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"docs":{}}}}}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"[":{"0":{"docs":{},"]":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"docs":{}},"l":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"o":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}},"s":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}}},"[":{"2":{"docs":{},"]":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"docs":{}}}}}},"s":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}}}}}}}}},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.007444168734491315}}}}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"가":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"u":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"i":{"docs":{},"s":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"n":{"docs":{},"g":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}},"r":{"docs":{},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156}}}}}}},".":{"docs":{},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"j":{"docs":{},"s":{"docs":{},")":{"docs":{},"과":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}},"s":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.00641025641025641},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.005917159763313609},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0077474892395982785},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.008528784648187633},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.015050167224080268},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.005050505050505051},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00839091806515301},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.00641025641025641},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0052417006406523005},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.004273504273504274},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.006396588486140725},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.009287925696594427}}},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004137931034482759},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0034944670937682005},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.006396588486140725},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.015479876160990712}}},";":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008417508417508417},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004545454545454545},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.008283479061205707},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.007403751233958539},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002758620689655172},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.003875968992248062},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0029498525073746312},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0036982248520710057},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.017057569296375266},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.006191950464396285},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},")":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}},"[":{"docs":{},"]":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705}},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"\"":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}}}},"과":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"]":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}},"으":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"i":{"docs":{},"c":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"s":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}}}}}}}}}}},")":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"인":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"e":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}}}}}}}}}}}}},"같":{"docs":{},"은":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00331858407079646},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.009615384615384616}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}}}}},"}":{"docs":{},"'":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},")":{"docs":{},";":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"은":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"c":{"docs":{},"t":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},"r":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"s":{"docs":{},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"에":{"docs":{},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"와":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"을":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},"s":{"docs":{},"이":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}}}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"a":{"docs":{},"l":{"docs":{},"[":{"1":{"docs":{},"]":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"docs":{}}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"l":{"docs":{},"i":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":5.0036297640653356},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367}},"(":{"docs":{},"\"":{"docs":{},"j":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.005050505050505051},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"게":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"와":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"u":{"docs":{},"p":{"docs":{},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},"가":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},":":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}}}}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"i":{"docs":{},"c":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837}},"s":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"y":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"e":{"docs":{},"p":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"s":{"docs":{},")":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148}}}}},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"a":{"docs":{},"y":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}},"(":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}}}}},"v":{"docs":{},"e":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003927729772191673},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"m":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}},"m":{"docs":{},"i":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"p":{"docs":{},"l":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}}}}}}},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}},"f":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"r":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}},"라":{"docs":{},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148}},"d":{"docs":{},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"이":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"docs":{}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}},"o":{"docs":{},"r":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"(":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}},"에":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}}}}}}}}}},":":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}}}}}}}}}},"r":{"docs":{},"v":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},"s":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"]":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"라":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}}}}}}}}}},"l":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004076878276062901},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"(":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}}}},"(":{"docs":{},"d":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"e":{"docs":{},"r":{"docs":{},"가":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"s":{"docs":{},":":{"docs":{},"[":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}},"으":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}},"[":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}}}}},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"(":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}}}}}}}}}},"p":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"a":{"docs":{},"r":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}}},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0054446460980036296},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}},":":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}},"m":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}},"h":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"m":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"o":{"docs":{},"w":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"(":{"docs":{},"\"":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}}}},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"s":{"docs":{},"하":{"docs":{},"기":{"docs":{},"때":{"docs":{},"문":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0051813471502590676}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},".":{"docs":{},"c":{"docs":{},"i":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}}}}}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"s":{"docs":{},".":{"docs":{},"p":{"docs":{},"o":{"docs":{},"l":{"docs":{},"y":{"docs":{},"g":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},"'":{"docs":{},"와":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}}}}}},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}}}}}}}},"?":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}}},"t":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}}}}}}}},"은":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505}}}}}}}}}}}}}}},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}}},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445}}},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"i":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}},"f":{"docs":{},"i":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}}}}},"d":{"docs":{},"e":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"s":{"docs":{},")":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.007739938080495356}},"e":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793}}}},"s":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"시":{"docs":{},"그":{"docs":{},"니":{"docs":{},"처":{"docs":{},"의":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}}}},"\"":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}}}}}}}}},"z":{"docs":{},"e":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"(":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"g":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"{":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"'":{"docs":{},")":{"docs":{},".":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},".":{"docs":{},"/":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"(":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"[":{"docs":{},"\"":{"docs":{},".":{"docs":{},"/":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"\"":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},"s":{"docs":{},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}},"m":{"1":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},"2":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.011406844106463879}}},"3":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}},";":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}},"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855}},"(":{"docs":{},"\"":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.011406844106463879}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}},")":{"docs":{},";":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.011406844106463879}}}}},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.014814814814814815}}}}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}}}},"s":{"docs":{},")":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}},"은":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"된":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"s":{"docs":{},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"n":{"docs":{},"c":{"docs":{},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}},"o":{"docs":{},"n":{"docs":{},"y":{"docs":{},"m":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}}},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.009426551453260016},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"s":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}},"도":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"이":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"을":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}}}}}},"r":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}},")":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"(":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}},"t":{"docs":{},"h":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}},"y":{"docs":{},"p":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"y":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}},".":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}}}},"w":{"docs":{},"h":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"r":{"docs":{},"t":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}},"r":{"docs":{},"c":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"/":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"s":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{},"s":{"docs":{},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}}}}}}}}}}},":":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},"u":{"docs":{},"d":{"docs":{},"o":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"m":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"(":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}}}}}}}}}}}}}}},"b":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},"\"":{"docs":{},"라":{"docs":{},"고":{"docs":{},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}},"l":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}}}}},"i":{"docs":{},"t":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}},"\"":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004137931034482759}}},"s":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149}}},"[":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}},"r":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}},")":{"docs":{},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}},"h":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},"r":{"docs":{},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.003629764065335753},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.006872852233676976}}},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"블":{"docs":{},"록":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"m":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"에":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}}}},"n":{"docs":{},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135}},"i":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"a":{"docs":{},"l":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}}},"a":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}},"o":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"q":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505}},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793}},")":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"를":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"?":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"r":{"docs":{},"q":{"docs":{},"/":{"docs":{},"t":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"m":{"docs":{},"i":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}},")":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.007444168734491315}}}}}},"와":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},")":{"docs":{},"[":{"docs":{},"]":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}}}}}}}},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"u":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}}}}}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}}}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0025811209439528023},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}}}}}}}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"f":{"docs":{},"c":{"docs":{},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"를":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}}},"u":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"p":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0045662100456621},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}}}},"s":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.020871143375680582},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.019189765458422176},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.02786377708978328},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.012953367875647668},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.030927835051546393},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.027972027972027972},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"e":{"docs":{},"r":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008417508417508417},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"\"":{"docs":{},";":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367}}}},"s":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"와":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}},"a":{"docs":{},"g":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.003629764065335753},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.004713275726630008}}},"y":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"c":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}},"b":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135}}}}}}}}}}}},"f":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"m":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.019963702359346643}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"를":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},")":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00422654268808115},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"e":{"docs":{},"d":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"와":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"'":{"docs":{},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}},"라":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}},"r":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135}},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"s":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"u":{"docs":{},"s":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"이":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}},"t":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"h":{"docs":{},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"b":{"docs":{},"a":{"docs":{},"d":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}},"n":{"docs":{},"t":{"3":{"2":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}}},"docs":{}},"docs":{}}},"컨":{"docs":{},"트":{"docs":{},"롤":{"docs":{},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"템":{"docs":{},"플":{"docs":{},"릿":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},")":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"r":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"v":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"i":{"docs":{},"s":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.006734006734006734},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{},"i":{"docs":{},"o":{"2":{"0":{"1":{"5":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}},"n":{"docs":{},"y":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.004713275726630008}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"e":{"docs":{},"w":{"1":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"2":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}},"a":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}},"a":{"docs":{},"r":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.006042296072507553},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.024351924587588374},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0050704225352112674},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.009726725335803613},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020086083213773313},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0029498525073746312},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005917159763313609},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.011553273427471117},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.012704174228675136},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.010835913312693499},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0051813471502590676},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.030395136778115502}},"보":{"docs":{},"다":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"와":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.003629764065335753},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.01279317697228145},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}},"e":{"docs":{},")":{"docs":{},"을":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"s":{"docs":{},")":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},"t":{"docs":{},"i":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}},"l":{"docs":{},"u":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.006191950464396285},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.034974093264248704}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0034944670937682005}}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}}},"i":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.010683760683760684},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}}}}},")":{"docs":{},"와":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}}}}}}}}}}}}}}}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}}}}}}}}}}}}}}}}}}}}}},"라":{"docs":{},"는":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}},"[":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"]":{"docs":{},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}}}}}}}}}}}}}}}}}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.004273504273504274}}}}},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0033812341504649195},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135}}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.015584415584415584},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.008528784648187633},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.010835913312693499}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"와":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},"이":{"docs":{},"기":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},">":{"docs":{},"(":{"docs":{},"(":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"과":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},"s":{"2":{"0":{"1":{"5":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}},"7":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.013824884792626729}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"와":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"s":{"1":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.013824884792626729}}},"docs":{}}}}}}}}}}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004}}},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},"?":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165}}}}}}}},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"w":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"e":{"docs":{},"b":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004545454545454545},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"은":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909}}},"이":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"l":{"docs":{},"l":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.010309278350515464}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"'":{"docs":{},"l":{"docs":{},"l":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148}}}},"v":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"w":{"docs":{},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},"d":{"docs":{},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}},"y":{"docs":{},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}},"y":{"docs":{},"(":{"docs":{},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"{":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"?":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}},"r":{"docs":{},"n":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"y":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}},"n":{"docs":{},"t":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}},"s":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004437869822485207}},"!":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"\"":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"\"":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.006396588486140725}}}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"d":{"docs":{},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"k":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}},"s":{"docs":{},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},"t":{"docs":{},"h":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}},"o":{"docs":{},"f":{"docs":{},"!":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.010835913312693499},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.010309278350515464}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.009074410163339383},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.007739938080495356},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}},":":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.010835913312693499}}}},"t":{"docs":{},"e":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}}}},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"v":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},"n":{"docs":{},"e":{"docs":{},"v":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}}}},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"v":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"y":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.007739938080495356}}}}},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}},"?":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793}}}},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.010660980810234541}},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}},"[":{"docs":{},"]":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"보":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.007444168734491315}}}}}}}}}}}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"l":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}},"{":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.016835016835016835},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.023162134944612285},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.019638648860958365},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.014647887323943662},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.015909090909090907},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00422654268808115},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.024085224641037517},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.028992176714219973},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.03603158933859822},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.022068965517241378},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.02026554856743536},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.023744292237442923},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.007444168734491315},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.017054263565891473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.03185078909612626},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.022222222222222223},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.035398230088495575},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.041666666666666664},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.013651877133105802},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.009018036072144289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.04148278905560459},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.031804733727810654},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0343622597553873},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.05194805194805195},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.010183299389002037},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.01797175866495507},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.010889292196007259},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.02771855010660981},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.017027863777089782},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.03367875647668394},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.010309278350515464},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.02130681818181818},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.03343465045592705}},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"}":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"}":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}}},"m":{"docs":{},"y":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"}":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"}":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}},"{":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},"}":{"docs":{},"}":{"docs":{},"`":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}},"a":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"}":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0041417395306028535},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},")":{"docs":{},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"이":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"}":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"}":{"docs":{},"!":{"docs":{},";":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"}":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"}":{"docs":{},"!":{"docs":{},";":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}}}}}},"o":{"docs":{},"o":{"docs":{},"}":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},"x":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078}}}},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}},"y":{"docs":{},"}":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}},"\"":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"[":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}}}}}}}},"i":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}},"a":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"}":{"docs":{},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}}}},"}":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.015151515151515152},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.011077542799597181},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.009426551453260016},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.009577464788732394},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.007954545454545454},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.005917159763313609},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.018063918480778138},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.02393005062126093},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.03504442250740375},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.016551724137931035},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.01816911250873515},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.021004566210045664},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.014728682170542635},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.030416068866571017},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.022222222222222223},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.029498525073746312},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.041666666666666664},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.010238907849829351},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.008517034068136272},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.03971756398940865},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.029585798816568046},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.033197437390797904},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.03896103896103896},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.01540436456996149},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.008166969147005444},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.02771855010660981},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.017027863777089782},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.027202072538860103},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.010309278350515464},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.018465909090909092},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.015197568389057751}},";":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.003242241778601204},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0041417395306028535},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004137931034482759},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.006042296072507553},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.006284367635506678},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0029498525073746312},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.01038961038961039},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.006396588486140725},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00911854103343465}}},".":{"docs":{},"p":{"docs":{},"l":{"docs":{},"u":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}},"}":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},")":{"docs":{},";":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0033802816901408453},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.006818181818181818},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}}},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"이":{"docs":{},"며":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"객":{"docs":{},"체":{"docs":{},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}},"으":{"docs":{},"로":{"docs":{},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"[":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"]":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}}},"`":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}}}}},"인":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"'":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},".":{"docs":{},"`":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}},"능":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}},"한":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}},"성":{"docs":{},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"할":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"하":{"docs":{},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"다":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"면":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"거":{"docs":{},"나":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"지":{"docs":{},"만":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}},"의":{"docs":{},"미":{"docs":{},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}},"해":{"docs":{},"야":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"져":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},"가":{"docs":{},"면":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"오":{"docs":{},"려":{"docs":{},"면":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"도":{"docs":{},"록":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"고":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"올":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"온":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}},"다":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"왔":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"\"":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}}}}}}},"야":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}}}}},"와":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"야":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"옵":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"짐":{"docs":{},"으":{"docs":{},"로":{"docs":{},"써":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}},"이":{"docs":{},"드":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.015810276679841896}}},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}}},"정":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"즉":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"간":{"docs":{},"단":{"docs":{},"히":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"예":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}},"며":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"해":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"을":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"지":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0033812341504649195},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002779064381658175},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.002582496413199426},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.00250501002004008},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.004507042253521127},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}},"있":{"docs":{},"기":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},"므":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"며":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"게":{"docs":{},"되":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"가":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"장":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0033802816901408453},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.01488833746898263},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"진":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"질":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"뿐":{"docs":{},"만":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"수":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"집":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{},"와":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}},"하":{"docs":{},"나":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"실":{"docs":{},"제":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}},"르":{"docs":{},"쳐":{"docs":{},"줄":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"드":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}},"와":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"임":{"docs":{},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"깝":{"docs":{},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}},"독":{"docs":{},"성":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"짜":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"상":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"시":{"docs":{},"성":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},"객":{"docs":{},"체":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.006418485237483954},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0032213529682466636},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.015209125475285171},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0025811209439528023},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"도":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}},"도":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.011406844106463879},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.018518518518518517},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"이":{"docs":{},"것":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}},"마":{"docs":{},"다":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"의":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"처":{"docs":{},"럼":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"만":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"인":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"것":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"과":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"은":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002779064381658175},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006109979633401222},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636}}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.003943661971830986},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.005681818181818182},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.006021306160259379},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004137931034482759},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.002582496413199426},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0022123893805309734},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.003943661971830986},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.003875968992248062},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"라":{"docs":{},"고":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"면":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"므":{"docs":{},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"든":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"그":{"docs":{},"것":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}},"다":{"docs":{},".":{"docs":{},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"차":{"docs":{},"이":{"docs":{},"점":{"docs":{},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.005681818181818182},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.005590496156533892},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}},"에":{"docs":{},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}}}}},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{},"와":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"즉":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"각":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"다":{"docs":{},"행":{"docs":{},"히":{"docs":{},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"른":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"음":{"docs":{},"장":{"docs":{},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"대":{"docs":{},"신":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"것":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"러":{"docs":{},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"제":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"렇":{"docs":{},"게":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"종":{"docs":{},"종":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"첫":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"파":{"docs":{},"일":{"docs":{},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"은":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"예":{"docs":{},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"그":{"docs":{},"러":{"docs":{},"나":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"리":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"선":{"docs":{},"언":{"docs":{},"전":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"변":{"docs":{},"수":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"게":{"docs":{},"다":{"docs":{},"가":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}},"또":{"docs":{},"한":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"반":{"docs":{},"면":{"docs":{},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"대":{"docs":{},"로":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}},"언":{"docs":{},"제":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"여":{"docs":{},"기":{"docs":{},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}},"러":{"docs":{},"분":{"docs":{},"은":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}},"타":{"docs":{},"입":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"현":{"docs":{},"재":{"docs":{},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"결":{"docs":{},"합":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"열":{"docs":{},"거":{"docs":{},"형":{"docs":{},"은":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"모":{"docs":{},"듈":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"에":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"의":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"앞":{"docs":{},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"전":{"docs":{},"역":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"만":{"docs":{},"일":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"생":{"docs":{},"성":{"docs":{},"자":{"docs":{},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"!":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}},")":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"들":{"docs":{},"에":{"docs":{},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"인":{"docs":{},"지":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"처":{"docs":{},"럼":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"도":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"조":{"docs":{},"차":{"docs":{},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"결":{"docs":{},"과":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"로":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"인":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"정":{"docs":{},"할":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}},"기":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"다":{"docs":{},"시":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"단":{"docs":{},"일":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"사":{"docs":{},"용":{"docs":{},"할":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"된":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"x":{"docs":{},".":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"합":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"하":{"docs":{},"여":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"세":{"docs":{},"요":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"러":{"docs":{},"한":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"따":{"docs":{},"라":{"docs":{},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"될":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"되":{"docs":{},"어":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}},"을":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},"한":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"(":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},"을":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}},"된":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"국":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"코":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"론":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"고":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"계":{"docs":{},"약":{"docs":{},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}}}},"속":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003927729772191673},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"해":{"docs":{},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"일":{"docs":{},"치":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}},"획":{"docs":{},"이":{"docs":{},"라":{"docs":{},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"산":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"되":{"docs":{},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"된":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"하":{"docs":{},"는":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"기":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}},"층":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"적":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"으":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"내":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"부":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}},"만":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"가":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}},"용":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}},"은":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.00919732441471572},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.013824884792626729}}},"이":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"만":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"의":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},":":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0182370820668693}}}},"보":{"docs":{},"내":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00331858407079646}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"\"":{"docs":{},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"도":{"docs":{},"록":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}},"만":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"냅":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.004180602006688963}},"소":{"docs":{},"스":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"낸":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"다":{"docs":{},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"낼":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"가":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"려":{"docs":{},"야":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"키":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"장":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005177514792899409}},"객":{"docs":{},"체":{"docs":{},"는":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}},"된":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"고":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"놓":{"docs":{},"고":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"일":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"눌":{"docs":{},"러":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}},"도":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"더":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00422654268808115},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.003242241778601204},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948}},"욱":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"이":{"docs":{},"상":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}}},"한":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"도":{"docs":{},"구":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"와":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":3.333333333333333}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},"가":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"들":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"만":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"뿐":{"docs":{},"만":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"움":{"docs":{},"말":{"docs":{},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"이":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"달":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"입":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"된":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"하":{"docs":{},"기":{"docs":{},"보":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"해":{"docs":{},"야":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"하":{"docs":{},"위":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},")":{"docs":{},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}}}}}}}}},"됨":{"docs":{},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"할":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"와":{"docs":{},"줍":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"기":{"docs":{},"존":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}}}}},"메":{"docs":{},"인":{"docs":{},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"동":{"docs":{},"일":{"docs":{},"하":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}},"지":{"docs":{},"만":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"므":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"게":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"한":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"다":{"docs":{},"른":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"(":{"docs":{},"즉":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},")":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}},"안":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"적":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}},"이":{"docs":{},"고":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"인":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"으":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"시":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"작":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"단":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"은":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"하":{"docs":{},"는":{"docs":{},"지":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"지":{"docs":{},"만":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"기":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"를":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"형":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"(":{"docs":{},"h":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"p":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},")":{"docs":{},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"인":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}},"될":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0034940600978336828},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"것":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},")":{"docs":{},"문":{"docs":{},"자":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}},"따":{"docs":{},"라":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"와":{"docs":{},"야":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"야":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"할":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"른":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}}},"옴":{"docs":{},"표":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"(":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"'":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}},"릅":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"르":{"docs":{},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"면":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"때":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0033812341504649195},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.003242241778601204},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0041417395306028535},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.003948667324777887},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0036781609195402297},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0041928721174004195},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.009925558312655087},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.005426356589147287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0031563845050215206},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006109979633401222},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.005016722408026756}},"마":{"docs":{},"다":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}},"문":{"docs":{},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0024679170779861796},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0036781609195402297},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.006201550387596899},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.002582496413199426},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},")":{"docs":{},".":{"docs":{},"그":{"docs":{},"러":{"docs":{},"나":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"다":{"docs":{},"음":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"생":{"docs":{},"성":{"docs":{},"자":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"것":{"docs":{},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"와":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"즉":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"왜":{"docs":{},"냐":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"함":{"docs":{},"수":{"docs":{},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"기":{"docs":{},"본":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}},"이":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"때":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"로":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"까":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"떄":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"또":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.003943661971830986},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00507185122569738},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0032213529682466636},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0045662100456621},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0028694404591104736},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.004793510324483776},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.003006012024048096},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0036982248520710057},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.008736167734420501},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006109979633401222},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.01},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"한":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002779064381658175},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.007686932215234102},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"리":{"docs":{},"팩":{"docs":{},"토":{"docs":{},"링":{"docs":{},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"해":{"docs":{},"야":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"스":{"docs":{},"트":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}},"이":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"에":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"서":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"도":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"가":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"터":{"docs":{},"럴":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.006392694063926941},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0028694404591104736},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"과":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"처":{"docs":{},"럼":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}},"액":{"docs":{},"트":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":3.333333333333333},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"뷰":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"턴":{"docs":{},"문":{"docs":{},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"다":{"docs":{},"이":{"docs":{},"렉":{"docs":{},"트":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}},"마":{"docs":{},"우":{"docs":{},"스":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"지":{"docs":{},"막":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"찬":{"docs":{},"가":{"docs":{},"지":{"docs":{},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0033812341504649195},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"여":{"docs":{},"기":{"docs":{},"에":{"docs":{},"서":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"모":{"docs":{},"듈":{"docs":{},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"그":{"docs":{},"레":{"docs":{},"이":{"docs":{},"션":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":5.0011267605633805}}}}}},"너":{"docs":{},"스":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"술":{"docs":{},"을":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"음":{"docs":{},"이":{"docs":{},"겠":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"치":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"세":{"docs":{},"요":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"!":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"\"":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948}}}}},"찰":{"docs":{},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"무":{"docs":{},"리":{"docs":{},"합":{"docs":{},"시":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"들":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}},"고":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"기":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}},"어":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},"졌":{"docs":{},"으":{"docs":{},"며":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"지":{"docs":{},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"야":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"냅":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}}},"면":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"려":{"docs":{},"고":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}}}},"듭":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"것":{"docs":{},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"여":{"docs":{},"러":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"“":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"”":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},"약":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"큼":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"드":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"든":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"하":{"docs":{},"면":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},"매":{"docs":{},"개":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.007444168734491315},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.018604651162790697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020086083213773313},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.008985879332477536},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"변":{"docs":{},"수":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.008735632183908045},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0052417006406523005},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"(":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"s":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}},"여":{"docs":{},"기":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.004891684136967156},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002758620689655172},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},"들":{"docs":{},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"을":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"라":{"docs":{},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"와":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"처":{"docs":{},"럼":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}},"니":{"docs":{},"저":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}},"우":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"(":{"docs":{},"극":{"docs":{},"단":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}},"기":{"docs":{},"기":{"docs":{},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"핑":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"된":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}},"과":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"을":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"되":{"docs":{},"어":{"docs":{},"야":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"칭":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636}}}},"명":{"docs":{},"령":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"줄":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}},"문":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"과":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"시":{"docs":{},"적":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"(":{"docs":{},"또":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"인":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"하":{"docs":{},"려":{"docs":{},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"기":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"해":{"docs":{},"야":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"주":{"docs":{},"지":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}},"된":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"확":{"docs":{},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"하":{"docs":{},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},"심":{"docs":{},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"사":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"백":{"docs":{},"하":{"docs":{},"기":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"제":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"명":{"docs":{},"제":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"칭":{"docs":{},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"몇":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},"가":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"몇":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}},"개":{"docs":{},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"목":{"docs":{},"록":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"이":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"만":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"은":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"가":{"docs":{},"능":{"docs":{},"한":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"내":{"docs":{},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"보":{"docs":{},"기":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}},"적":{"docs":{},"상":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"을":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"인":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"표":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"못":{"docs":{},"한":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"다":{"docs":{},"면":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"하":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"면":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"이":{"docs":{},"런":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}},"바":{"docs":{},"꿀":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735}}},"꾸":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}}},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"꿔":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"보":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"제":{"docs":{},"네":{"docs":{},"릭":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}}}},"서":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"깥":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"람":{"docs":{},"직":{"docs":{},"한":{"docs":{},"지":{"docs":{},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"하":{"docs":{},"지":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}}}},"인":{"docs":{},"딩":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"에":{"docs":{},"서":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}},"보":{"docs":{},"같":{"docs":{},"은":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"이":{"docs":{},"너":{"docs":{},"리":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"트":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"운":{"docs":{},"드":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"랍":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}}},"발":{"docs":{},"전":{"docs":{},"시":{"docs":{},"켜":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}},"견":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"오":{"docs":{},"류":{"docs":{},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}},"되":{"docs":{},"지":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"생":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"하":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"지":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543}}},"여":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{},"e":{"docs":{},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}}}}}}}}}},"그":{"docs":{},"러":{"docs":{},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"해":{"docs":{},"야":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"시":{"docs":{},"키":{"docs":{},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"킵":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"한":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"명":{"docs":{},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"휘":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"방":{"docs":{},"법":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"은":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"이":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}},"것":{"docs":{},"은":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"러":{"docs":{},"한":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}}}}}},"매":{"docs":{},"개":{"docs":{},"변":{"docs":{},"수":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"예":{"docs":{},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.023715415019762844}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724}},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"며":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"기":{"docs":{},"도":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"으":{"docs":{},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"도":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"임":{"docs":{},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"식":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"든":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"출":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"되":{"docs":{},"며":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"된":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"될":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"하":{"docs":{},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"고":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"기":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"할":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}},"에":{"docs":{},"는":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"을":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"지":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}},"하":{"docs":{},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"려":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"금":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"향":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"\"":{"docs":{},"에":{"docs":{},"서":{"docs":{},"도":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}},"문":{"docs":{},"할":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"배":{"docs":{},"열":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.007444168734491315},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0041928721174004195}}},"에":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"이":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}},"며":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}},"(":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"치":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"웠":{"docs":{},"고":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"우":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"워":{"docs":{},"야":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"포":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948}},"하":{"docs":{},"는":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"기":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"다":{"docs":{},"음":{"docs":{},"과":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}},"변":{"docs":{},"수":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":5.006484483557203},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.007444168734491315},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.006484483557202408},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.003875968992248062},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724}}},"가":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"서":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}},"y":{"docs":{},"에":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"와":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"들":{"docs":{},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"매":{"docs":{},"우":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}},"인":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},")":{"docs":{},".":{"docs":{},"이":{"docs":{},"러":{"docs":{},"한":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}}}},"경":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"하":{"docs":{},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"여":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"지":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"도":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"면":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"되":{"docs":{},"지":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"\"":{"docs":{},"내":{"docs":{},"부":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}},"될":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"할":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},".":{"docs":{},"이":{"docs":{},"제":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"편":{"docs":{},"리":{"docs":{},"하":{"docs":{},"게":{"docs":{},"도":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}},"해":{"docs":{},"야":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"가":{"docs":{},"령":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}},"을":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"환":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"려":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"할":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"예":{"docs":{},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"즉":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"(":{"docs":{},"타":{"docs":{},"입":{"docs":{},"캐":{"docs":{},"스":{"docs":{},"팅":{"docs":{},")":{"docs":{},"과":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}},"해":{"docs":{},"봅":{"docs":{},"시":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"되":{"docs":{},"는":{"docs":{},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"로":{"docs":{},"더":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"하":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"형":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"것":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"시":{"docs":{},"키":{"docs":{},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"되":{"docs":{},"어":{"docs":{},"야":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"화":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"이":{"docs":{},"들":{"docs":{},"의":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}},"보":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}}}}}}}}},"이":{"docs":{},"것":{"docs":{},"은":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"먼":{"docs":{},"저":{"docs":{},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":2.5}}},"게":{"docs":{},"해":{"docs":{},"야":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"려":{"docs":{},"면":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"일":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"냅":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"통":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"았":{"docs":{},"을":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"여":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}},"줄":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"줍":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"코":{"docs":{},"드":{"docs":{},"가":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"이":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"야":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"내":{"docs":{},"장":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}},"주":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"하":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.005852842809364548}},"상":{"docs":{},"속":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}},"된":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"세":{"docs":{},"요":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}},"이":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"다":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"면":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"기":{"docs":{},"존":{"docs":{},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"장":{"docs":{},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"하":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"되":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"강":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"수":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"편":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"시":{"docs":{},"길":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"지":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"복":{"docs":{},"사":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{},"식":{"docs":{},"별":{"docs":{},"자":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}}}},"거":{"docs":{},"나":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"고":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"본":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"런":{"docs":{},"타":{"docs":{},"임":{"docs":{},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}},"잡":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"배":{"docs":{},"열":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"이":{"docs":{},"전":{"docs":{},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}},"한":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}},"하":{"docs":{},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"볼":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00706090026478376},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"봅":{"docs":{},"시":{"docs":{},"다":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}}}},"그":{"docs":{},"러":{"docs":{},"면":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"이":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"분":{"docs":{},"석":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"해":{"docs":{},"보":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}},"리":{"docs":{},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"하":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"된":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"명":{"docs":{},"히":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"해":{"docs":{},"집":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"류":{"docs":{},"된":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"x":{"docs":{},".":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}}}}}}},"할":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"하":{"docs":{},"는":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}},"불":{"docs":{},"구":{"docs":{},"하":{"docs":{},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}},"평":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"러":{"docs":{},"오":{"docs":{},"기":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"법":{"docs":{},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"임":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"변":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"이":{"docs":{},"며":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}},"행":{"docs":{},"히":{"docs":{},"도":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"투":{"docs":{},"명":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}},"가":{"docs":{},"능":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"필":{"docs":{},"요":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"한":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"림":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"립":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"네":{"docs":{},"임":{"docs":{},"스":{"docs":{},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{},"를":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}}}}}}},"과":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"리":{"docs":{},"하":{"docs":{},"여":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"붙":{"docs":{},"여":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"넣":{"docs":{},"기":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}},"야":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"이":{"docs":{},"겠":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"반":{"docs":{},"대":{"docs":{},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}},"은":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"을":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"새":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"운":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.003242241778601204},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0024679170779861796},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.003443328550932568},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"고":{"docs":{},"침":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"롭":{"docs":{},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},"샘":{"docs":{},"플":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"에":{"docs":{},"서":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}},"생":{"docs":{},"성":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"된":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705}},"다":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}},"코":{"docs":{},"드":{"docs":{},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}},"이":{"docs":{},"로":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}},"자":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.005923000987166831},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004076878276062901}},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"와":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"의":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}},"해":{"docs":{},"당":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"원":{"docs":{},"시":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"타":{"docs":{},"입":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"생":{"docs":{},"성":{"docs":{},"된":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"여":{"docs":{},"기":{"docs":{},"에":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"이":{"docs":{},"것":{"docs":{},"은":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}}}}},"하":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0024679170779861796}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"려":{"docs":{},"고":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"면":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"며":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"할":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}},"해":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"야":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"되":{"docs":{},"면":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"기":{"docs":{},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"각":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"여":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"면":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"해":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"야":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}},"보":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"할":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"태":{"docs":{},"계":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"긴":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"략":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"할":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},"될":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"기":{"docs":{},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"깁":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"설":{"docs":{},"명":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"데":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"우":{"docs":{},"리":{"docs":{},"가":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}},"려":{"docs":{},"면":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"고":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"까":{"docs":{},"요":{"docs":{},"?":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"된":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948}},"즉":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"각":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"용":{"docs":{},"어":{"docs":{},"에":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"또":{"docs":{},"한":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"특":{"docs":{},"히":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}},"을":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"되":{"docs":{},"어":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"한":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},"대":{"docs":{},"로":{"docs":{},")":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}}}}},"치":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0182370820668693},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}},"하":{"docs":{},"기":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"지":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},".":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"t":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"u":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"처":{"docs":{},"럼":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}},"거":{"docs":{},"나":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"되":{"docs":{},"었":{"docs":{},"으":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"어":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"할":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"했":{"docs":{},"음":{"docs":{},"을":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"된":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"가":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"한":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"정":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.006042296072507553},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.011363636363636364},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"은":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"타":{"docs":{},"입":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"이":{"docs":{},"러":{"docs":{},"한":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},"해":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"야":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"이":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"하":{"docs":{},"여":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"거":{"docs":{},"나":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"지":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}},"되":{"docs":{},"어":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"었":{"docs":{},"다":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"면":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"지":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"과":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"이":{"docs":{},"런":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}},"시":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"계":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"되":{"docs":{},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"거":{"docs":{},"나":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"섹":{"docs":{},"션":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.011857707509881422}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"서":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.011857707509881422}}}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"으":{"docs":{},"로":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}},"속":{"docs":{},"성":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.008875739644970414},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005681818181818182},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.008522727272727272},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"(":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"과":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"으":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"은":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"에":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}},"하":{"docs":{},"지":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"시":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"작":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"해":{"docs":{},"봅":{"docs":{},"시":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}},"야":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"보":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"웹":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}}},"하":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"기":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"려":{"docs":{},"면":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}}}},"여":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"고":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"합":{"docs":{},"시":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"멤":{"docs":{},"버":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"다":{"docs":{},"른":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"각":{"docs":{},"각":{"docs":{},"의":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"이":{"docs":{},"것":{"docs":{},"은":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"한":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"으":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}},"된":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},"점":{"docs":{},"이":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},"간":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"이":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"에":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"스":{"docs":{},"템":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"두":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"기":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"은":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}},"의":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"점":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"서":{"docs":{},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"나":{"docs":{},"리":{"docs":{},"오":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"에":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"그":{"docs":{},"니":{"docs":{},"처":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"(":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"과":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"가":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"도":{"docs":{},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"하":{"docs":{},"게":{"docs":{},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"세":{"docs":{},"요":{"docs":{},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}}},"할":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"전":{"docs":{},"체":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"파":{"docs":{},"일":{"docs":{},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}},"험":{"docs":{},"용":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}},"적":{"docs":{},"인":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"에":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"퀀":{"docs":{},"스":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"실":{"docs":{},"행":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"되":{"docs":{},"지":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"어":{"docs":{},"야":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"면":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"며":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"하":{"docs":{},"기":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"면":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"도":{"docs":{},"록":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"며":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"게":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"려":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"여":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"지":{"docs":{},"만":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"이":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"될":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"해":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"시":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"키":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875}}}},"수":{"docs":{},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948}}},"\"":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"험":{"docs":{},"적":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"인":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"단":{"docs":{},"계":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"제":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"패":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}}},"한":{"docs":{},"다":{"docs":{},"면":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"시":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"질":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"심":{"docs":{},"볼":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":10.011406844106464}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"은":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.011406844106463879}}},"을":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"이":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},"과":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"에":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"플":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"지":{"docs":{},"어":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"안":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":2.5},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"전":{"docs":{},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"성":{"docs":{},"과":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}},"에":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"하":{"docs":{},"게":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"한":{"docs":{},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}},"다":{"docs":{},"\"":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"과":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"정":{"docs":{},"성":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"내":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"해":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},"알":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"려":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"줍":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"두":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"비":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"줘":{"docs":{},"야":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"주":{"docs":{},"어":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"는":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"진":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.011406844106463879},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"줌":{"docs":{},"으":{"docs":{},"로":{"docs":{},"써":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"져":{"docs":{},"야":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"아":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},"야":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"냈":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"그":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"보":{"docs":{},"기":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}}},"내":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"림":{"docs":{},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"게":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0033812341504649195},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}},"있":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"리":{"docs":{},"즘":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"은":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"리":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"립":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"렇":{"docs":{},"게":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}}}},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"겠":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"다":{"docs":{},"시":{"docs":{},"피":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"았":{"docs":{},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"으":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"릴":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"애":{"docs":{},"플":{"docs":{},"리":{"docs":{},"케":{"docs":{},"이":{"docs":{},"션":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676}}},"이":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"도":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}},"앱":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"에":{"docs":{},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"이":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"없":{"docs":{},"이":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705}},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}}}}}},"다":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"면":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.005134788189987163}},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0034940600978336828},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00353045013239188},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}},"일":{"docs":{},"반":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}},"즉":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"어":{"docs":{},"떤":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"예":{"docs":{},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"인":{"docs":{},"터":{"docs":{},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{},"와":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}},"기":{"docs":{},"본":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"컴":{"docs":{},"파":{"docs":{},"일":{"docs":{},"러":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}},"이":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"전":{"docs":{},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"것":{"docs":{},"은":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"그":{"docs":{},"것":{"docs":{},"들":{"docs":{},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"런":{"docs":{},"타":{"docs":{},"임":{"docs":{},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"사":{"docs":{},"용":{"docs":{},"자":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"상":{"docs":{},"대":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"`":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}},"프":{"docs":{},"로":{"docs":{},"퍼":{"docs":{},"티":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"!":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},")":{"docs":{},".":{"docs":{},"왜":{"docs":{},"냐":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"으":{"docs":{},"며":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"므":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"면":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"여":{"docs":{},"기":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"그":{"docs":{},"래":{"docs":{},"서":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}},"다":{"docs":{},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"지":{"docs":{},"만":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"음":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}}},"거":{"docs":{},"나":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"고":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"기":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"때":{"docs":{},"문":{"docs":{},"에":{"docs":{},"(":{"docs":{},"기":{"docs":{},"본":{"docs":{},"값":{"docs":{},"을":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}},"앨":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"러":{"docs":{},"가":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"디":{"docs":{},"터":{"docs":{},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"여":{"docs":{},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"도":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"서":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}},"세":{"docs":{},"요":{"docs":{},"!":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}},"전":{"docs":{},"히":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"왜":{"docs":{},"냐":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}}}}}},"러":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},"개":{"docs":{},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"분":{"docs":{},"의":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"부":{"docs":{},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}},"느":{"docs":{},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}},"겨":{"docs":{},"집":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}},"열":{"docs":{},"거":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603}},"나":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"형":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":10.039269406392695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.00821917808219178},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"과":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"에":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"서":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"으":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"은":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.010958904109589041},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"의":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0073059360730593605},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"아":{"docs":{},"래":{"docs":{},"에":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}},"까":{"docs":{},"지":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"하":{"docs":{},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"어":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"보":{"docs":{},"세":{"docs":{},"요":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"줍":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"려":{"docs":{},"있":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"올":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"바":{"docs":{},"른":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"르":{"docs":{},"게":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"라":{"docs":{},"갑":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}},"옵":{"docs":{},"션":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":5.003344481605351},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":3.343333333333333},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}},"들":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"j":{"docs":{},"s":{"docs":{},",":{"docs":{},"a":{"docs":{},"m":{"docs":{},"d":{"docs":{},",":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}}}}}}}}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0050704225352112674},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005681818181818182},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},"의":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"완":{"docs":{},"료":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"된":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"시":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"되":{"docs":{},"면":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},"성":{"docs":{},"과":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"전":{"docs":{},"히":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}},"하":{"docs":{},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"벽":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"한":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"만":{"docs":{},"한":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}},"요":{"docs":{},"구":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"사":{"docs":{},"항":{"docs":{},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}},"소":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.016272189349112426}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004437869822485207}},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"서":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"들":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}},"와":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}},"로":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},"이":{"docs":{},"며":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}}},"청":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"점":{"docs":{},"은":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"약":{"docs":{},"하":{"docs":{},"면":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}},"웹":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.006734006734006734},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"팩":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":3.3344696969696965}}}},"위":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"해":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0050704225352112674},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00422654268808115},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0029615004935834156},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0025811209439528023},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.00501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.011857707509881422},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},",":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"만":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},",":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"한":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0022123893805309734},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"치":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.003006012024048096},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"에":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},"만":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"가":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"하":{"docs":{},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"로":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"할":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}}},"와":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}},"험":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"에":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},")":{"docs":{},"와":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"키":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"인":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"수":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0041928721174004195},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"들":{"docs":{},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},"와":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"터":{"docs":{},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":10.003221352968247},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00529567519858782},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"가":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00353045013239188},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.006902899217671422},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"나":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"서":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"처":{"docs":{},"럼":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"보":{"docs":{},"다":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}},"셉":{"docs":{},"트":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"라":{"docs":{},"인":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{},"되":{"docs":{},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}}}}}}}}}}}}},"쇄":{"docs":{},"해":{"docs":{},"야":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"스":{"docs":{},"턴":{"docs":{},"스":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.006656804733727811},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0034944670937682005}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.003948667324777887}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"가":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"들":{"docs":{},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"에":{"docs":{},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"도":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"화":{"docs":{},"될":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"하":{"docs":{},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"므":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"할":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}},"식":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"지":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"비":{"docs":{},"슷":{"docs":{},"하":{"docs":{},"게":{"docs":{},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}}},"해":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"덱":{"docs":{},"스":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0041417395306028535},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0040172166427546625},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"서":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}},"서":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}},"에":{"docs":{},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"싱":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"하":{"docs":{},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"면":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"경":{"docs":{},"우":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"기":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"입":{"docs":{},"력":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"세":{"docs":{},"요":{"docs":{},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367}}}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"면":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"할":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"을":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"과":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"니":{"docs":{},"다":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"a":{"docs":{},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}},"c":{"docs":{},"#":{"docs":{},"와":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"즉":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"j":{"docs":{},"s":{"docs":{},"x":{"docs":{},".":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"증":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"자":{"docs":{},"동":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"바":{"docs":{},"스":{"docs":{},"크":{"docs":{},"립":{"docs":{},"트":{"docs":{},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}}}},"주":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"세":{"docs":{},"한":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.00250501002004008},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.008361204013377926},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0243161094224924},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.013824884792626729}}},"히":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"체":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"인":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"가":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}}},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"와":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"리":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"유":{"docs":{},"롭":{"docs":{},"게":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"료":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"신":{"docs":{},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"만":{"docs":{},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}}}},"연":{"docs":{},"스":{"docs":{},"럽":{"docs":{},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}},"식":{"docs":{},"들":{"docs":{},"만":{"docs":{},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"기":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"작":{"docs":{},"동":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"하":{"docs":{},"여":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"지":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"에":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},"도":{"docs":{},"록":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"며":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},"지":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"만":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"려":{"docs":{},"면":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}}}}}}}}}},"간":{"docs":{},"단":{"docs":{},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}},"이":{"docs":{},"를":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"매":{"docs":{},"핑":{"docs":{},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"한":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}},"할":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"업":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"할":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"수":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"는":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"하":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},"기":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"성":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"할":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"마":{"docs":{},"지":{"docs":{},"막":{"docs":{},"으":{"docs":{},"로":{"docs":{},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},"해":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"보":{"docs":{},"세":{"docs":{},"요":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"다":{"docs":{},"음":{"docs":{},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"야":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"하":{"docs":{},"게":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.019762845849802372}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"든":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"여":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"했":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"다":{"docs":{},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"면":{"docs":{},":":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}},"으":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}},"된":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"되":{"docs":{},"며":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}}}},"자":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"될":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"에":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"의":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"은":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}}},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"용":{"docs":{},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}},"문":{"docs":{},"자":{"docs":{},"열":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"중":{"docs":{},"요":{"docs":{},"한":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}},"하":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"잘":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.011406844106463879},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"못":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"된":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"적":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"다":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}},"용":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"하":{"docs":{},"면":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"일":{"docs":{},"반":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}},"이":{"docs":{},"를":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"매":{"docs":{},"개":{"docs":{},"변":{"docs":{},"수":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}},"할":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"되":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"지":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"기":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"며":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002}}},"어":{"docs":{},"야":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"된":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"다":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"합":{"docs":{},"한":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"하":{"docs":{},"도":{"docs":{},"록":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"어":{"docs":{},"도":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"x":{"docs":{},"와":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"야":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"재":{"docs":{},"할":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"절":{"docs":{},"한":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"하":{"docs":{},"게":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"정":{"docs":{},"보":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"도":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"가":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"와":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"여":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"기":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"만":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"려":{"docs":{},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"되":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"면":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"어":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"기":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"편":{"docs":{},"의":{"docs":{},"상":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"그":{"docs":{},"러":{"docs":{},"나":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}}}}},"이":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}},"한":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"된":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},"해":{"docs":{},"야":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"될":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"인":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"가":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"에":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"반":{"docs":{},"환":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}},"적":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004076878276062901}},"인":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"리":{"docs":{},"하":{"docs":{},"도":{"docs":{},"록":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"확":{"docs":{},"히":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"하":{"docs":{},"게":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"는":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"한":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"반":{"docs":{},"대":{"docs":{},"이":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}},"교":{"docs":{},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}},"말":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"로":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"도":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"렬":{"docs":{},"되":{"docs":{},"어":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"각":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}},"하":{"docs":{},"는":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}},"하":{"docs":{},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"했":{"docs":{},"으":{"docs":{},"며":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"해":{"docs":{},"진":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"규":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.019011406844106463}},"식":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}},"과":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}},"당":{"docs":{},"한":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"제":{"docs":{},"거":{"docs":{},"해":{"docs":{},"보":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}}}}}}}}}}}}},"야":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"면":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"된":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}}},"되":{"docs":{},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"공":{"docs":{},"된":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"고":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"며":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"려":{"docs":{},"면":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"게":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"한":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"할":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"일":{"docs":{},"단":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"이":{"docs":{},"것":{"docs":{},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"반":{"docs":{},"면":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"데":{"docs":{},"코":{"docs":{},"레":{"docs":{},"이":{"docs":{},"터":{"docs":{},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}},"원":{"docs":{},"래":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"\"":{"docs":{},".":{"docs":{},"또":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}},"되":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"지":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"만":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"될":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"했":{"docs":{},"는":{"docs":{},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"해":{"docs":{},"야":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}}},"\"":{"docs":{},"할":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"외":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}},"려":{"docs":{},"면":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},")":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}},".":{"docs":{},"특":{"docs":{},"히":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"되":{"docs":{},"는":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},"었":{"docs":{},"는":{"docs":{},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"해":{"docs":{},"야":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"선":{"docs":{},"택":{"docs":{},"사":{"docs":{},"항":{"docs":{},"을":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}},"일":{"docs":{},"반":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}},"된":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"될":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"j":{"docs":{},"s":{"docs":{},"가":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}}},"네":{"docs":{},"릭":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Generics.html":{"ref":"pages/Generics.html","tf":10.01956673654787},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.003875968992248062},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.007702182284980745},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"에":{"docs":{},"서":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"으":{"docs":{},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"을":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}},"이":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"므":{"docs":{},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"인":{"docs":{},"지":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"레":{"docs":{},"이":{"docs":{},"터":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":5}}}}}},"한":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"되":{"docs":{},"어":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"있":{"docs":{},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"지":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"을":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"하":{"docs":{},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"도":{"docs":{},"록":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"이":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"된":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"어":{"docs":{},"할":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"하":{"docs":{},"기":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"약":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"으":{"docs":{},"로":{"docs":{},"서":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"조":{"docs":{},"건":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"에":{"docs":{},"서":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"을":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}}}}},"안":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"될":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"이":{"docs":{},"며":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"대":{"docs":{},"로":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},"줄":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.008146639511201629},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"임":{"docs":{},"말":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}}},"표":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"(":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},")":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}},"은":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"도":{"docs":{},"록":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"지":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}},"일":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"중":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},"!":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}},"인":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},"했":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"간":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"요":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"그":{"docs":{},"렇":{"docs":{},"지":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"예":{"docs":{},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"전":{"docs":{},"통":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}},"하":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"다":{"docs":{},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"첩":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}},"된":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543}}}},"이":{"docs":{},"며":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"괄":{"docs":{},"호":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"첫":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"번":{"docs":{},"째":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"째":{"docs":{},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"추":{"docs":{},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.006042296072507553},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702}},"그":{"docs":{},"런":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"여":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.005134788189987163}}},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"자":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"거":{"docs":{},"나":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"지":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"할":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}},"n":{"docs":{},"p":{"docs":{},"m":{"docs":{},"과":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"이":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"표":{"docs":{},"현":{"docs":{},"이":{"docs":{},"나":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"테":{"docs":{},"스":{"docs":{},"트":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"@":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"를":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}},"생":{"docs":{},"성":{"docs":{},"된":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"해":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"야":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"보":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}},"되":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}},"기":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"이":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"인":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814}}}}}},"함":{"docs":{},"에":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"된":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"론":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":5},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"마":{"docs":{},"지":{"docs":{},"막":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}},"이":{"docs":{},"것":{"docs":{},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"러":{"docs":{},"한":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}}}},"된":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"하":{"docs":{},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"기":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"되":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"지":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"기":{"docs":{},"를":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}},"은":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.007444168734491315},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"이":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"렇":{"docs":{},"게":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}}}}}},"상":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.004442250740375123},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}},"화":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"된":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"적":{"docs":{},"이":{"docs":{},"지":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"측":{"docs":{},"을":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"적":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"하":{"docs":{},"고":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"커":{"docs":{},"서":{"docs":{},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}},"맨":{"docs":{},"드":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006109979633401222},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"라":{"docs":{},"인":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}}}}}}}},"스":{"docs":{},"텀":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"터":{"docs":{},"마":{"docs":{},"이":{"docs":{},"징":{"docs":{},"하":{"docs":{},"고":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}},"멘":{"docs":{},"드":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"뮤":{"docs":{},"니":{"docs":{},"티":{"docs":{},"에":{"docs":{},"서":{"docs":{},"도":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}}}}},"컴":{"docs":{},"파":{"docs":{},"일":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"러":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.008522727272727272},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":5.002508361204013},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":3.348333333333333},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.008146639511201629},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"게":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}}},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"따":{"docs":{},"라":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.006012024048096192},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636}}},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.006012024048096192},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"의":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"하":{"docs":{},"기":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"면":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}},"려":{"docs":{},"면":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{},"이":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"이":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"다":{"docs":{},"른":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}},"시":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"(":{"docs":{},"기":{"docs":{},"본":{"docs":{},"값":{"docs":{},")":{"docs":{},"을":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}},"된":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"할":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"의":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"포":{"docs":{},"넌":{"docs":{},"트":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946}}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036}}},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"퓨":{"docs":{},"터":{"docs":{},"에":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}},"코":{"docs":{},"드":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}},"가":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.008056394763343404},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.006284367635506678},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505}}},"와":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"는":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"처":{"docs":{},"럼":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"/":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}},"빌":{"docs":{},"드":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}},"어":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"딩":{"docs":{},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"되":{"docs":{},"어":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"크":{"docs":{},"게":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"지":{"docs":{},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687},"pages/Classes.html":{"ref":"pages/Classes.html","tf":10.005923000987167},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.004891684136967156},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00353045013239188},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.008875739644970414},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.010483401281304601},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0029615004935834156},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.006416584402764067},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.015584415584415584}}},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0034550839091806516},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0032213529682466636},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00839091806515301},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.005824111822947}}},"처":{"docs":{},"럼":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}}}}},"들":{"docs":{},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"뿐":{"docs":{},"만":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"인":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"또":{"docs":{},"한":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"추":{"docs":{},"상":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"파":{"docs":{},"생":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"네":{"docs":{},"임":{"docs":{},"스":{"docs":{},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{},"를":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}}}}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"라":{"docs":{},"면":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},")":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735}}}}},"로":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"식":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"이":{"docs":{},"며":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"릭":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}},"'":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"'":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}},"그":{"docs":{},"런":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"그":{"docs":{},"런":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}},"키":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"워":{"docs":{},"드":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"가":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"로":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}},"타":{"docs":{},"입":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.010101010101010102},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":5.005071851225697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0050621260929590425},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0036781609195402297},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.019566736547868623},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":5.042183622828784},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":5.013178294573644},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":5.015494978479197},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00529567519858782},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.016272189349112426},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":2.512836970474968},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.006688963210702341}},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"만":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"도":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.009298393913778529},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0029615004935834156},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.008735632183908045},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.009783368273934312},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.02977667493796526},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0069767441860465115},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.010329985652797705},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.006656804733727811},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.012836970474967908}}},"이":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00422654268808115},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002758620689655172},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.006289308176100629},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.019851116625310174},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00430416068866571},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004437869822485207}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"라":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"어":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}},"거":{"docs":{},"나":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}}}},"며":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"므":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"든":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"되":{"docs":{},"도":{"docs":{},"록":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"스":{"docs":{},"크":{"docs":{},"립":{"docs":{},"트":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"도":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00507185122569738},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.006902899217671422},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002758620689655172},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.005590496156533892},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.009925558312655087},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.008527131782945736},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0054519368723099},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00353045013239188},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0036982248520710057},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"인":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036}},"즉":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"매":{"docs":{},"개":{"docs":{},"변":{"docs":{},"수":{"docs":{},"와":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}},"(":{"docs":{},"왜":{"docs":{},"냐":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}},")":{"docs":{},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"이":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"도":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"보":{"docs":{},"다":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0084530853761623},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.009925558312655087},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.003443328550932568},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.008136094674556213},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},"\"":{"docs":{},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"을":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"u":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"예":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"상":{"docs":{},"위":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},"임":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"들":{"docs":{},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"전":{"docs":{},"체":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"변":{"docs":{},"수":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"를":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"처":{"docs":{},"럼":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}}},"라":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"뿐":{"docs":{},"만":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"이":{"docs":{},"프":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"핑":{"docs":{},"(":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"u":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}}}}}},"은":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"과":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"이":{"docs":{},"니":{"docs":{},"까":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}},"임":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"겟":{"docs":{},"이":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}}},"으":{"docs":{},"로":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}},"파":{"docs":{},"일":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004545454545454545},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0025811209439528023},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0035070140280561123},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0036982248520710057},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.008146639511201629},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":2.501283697047497},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.008522727272727272},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.007525083612040134},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0225},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"은":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005681818181818182},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"이":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.004008016032064128},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.009943181818181818},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.004180602006688963}},"나":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002}}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.012219959266802444},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005681818181818182},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"서":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006109979633401222},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.007702182284980745},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"와":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0054988216810683424},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.006197183098591549},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0125},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.005341880341880342},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.006825938566552901},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.009519038076152305},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.010183299389002037},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.03557312252964427},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.01278409090909091},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.007525083612040134},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"만":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"와":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}},"*":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{},"의":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{},"은":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}},"과":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.003006012024048096},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006109979633401222},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.007102272727272727},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.007525083612040134},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"뿐":{"docs":{},"만":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"들":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"은":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"별":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},":":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"처":{"docs":{},"럼":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"도":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"이":{"docs":{},"프":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"티":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"싱":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"에":{"docs":{},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"을":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"라":{"docs":{},"미":{"docs":{},"터":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}},"생":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078}},"되":{"docs":{},"기":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"된":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},"될":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"악":{"docs":{},"할":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"하":{"docs":{},"기":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"트":{"docs":{},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"패":{"docs":{},"키":{"docs":{},"지":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.013824884792626729}}},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"가":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636}}},"의":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005681818181818182}}},"만":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}}},"턴":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"\"":{"docs":{},"이":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"과":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"치":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"편":{"docs":{},"집":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"에":{"docs":{},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"하":{"docs":{},"는":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},"리":{"docs":{},"한":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"그":{"docs":{},"렇":{"docs":{},"게":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"예":{"docs":{},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}}}}}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}},"포":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"함":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"되":{"docs":{},"어":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636}}},"면":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"며":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"있":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}},"지":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"기":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"도":{"docs":{},"록":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"면":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"여":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"시":{"docs":{},"키":{"docs":{},"기":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"킬":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"킵":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"가":{"docs":{},"장":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"\"":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}}}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}},"\"":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"@":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"*":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}}}}}}}}}}}}}}},"된":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006109979633401222},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.007102272727272727},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005681818181818182},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"기":{"docs":{},"본":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}}}}}},"각":{"docs":{},"각":{"docs":{},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"일":{"docs":{},"부":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"최":{"docs":{},"종":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"트":{"docs":{},"리":{"docs":{},"플":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}},"\"":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}},"동":{"docs":{},"봉":{"docs":{},"된":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}},"한":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"해":{"docs":{},"야":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"될":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"위":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"이":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"맷":{"docs":{},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"으":{"docs":{},"로":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"은":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"과":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"이":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},"표":{"docs":{},"시":{"docs":{},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"되":{"docs":{},"지":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"만":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"어":{"docs":{},"야":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"면":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"고":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"된":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"이":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}},"될":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"하":{"docs":{},"도":{"docs":{},"록":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"는":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"준":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"현":{"docs":{},"식":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.011406844106463879},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004076878276062901}}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029585798816568047},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.007444168734491315},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}},"거":{"docs":{},"나":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"나":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"변":{"docs":{},"수":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"타":{"docs":{},"입":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}},"인":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"에":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"만":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"으":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"과":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"할":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"하":{"docs":{},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"기":{"docs":{},"법":{"docs":{},"을":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},"프":{"docs":{},"로":{"docs":{},"그":{"docs":{},"래":{"docs":{},"머":{"docs":{},"가":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}},"밍":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"과":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"램":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"부":{"docs":{},"터":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"토":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"타":{"docs":{},"입":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}},"을":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"이":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"젝":{"docs":{},"트":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.003006012024048096},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0075},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"가":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"퍼":{"docs":{},"티":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0041417395306028535},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0037302725968436155},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.015209125475285171},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.004008016032064128},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0128130460104834},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0036815462494247586},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0034940600978336828},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020086083213773313},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.014814814814814815},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0050621260929590425},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},"뿐":{"docs":{},"만":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"만":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}},"들":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}},"서":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}},"와":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"인":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}},"과":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},"을":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}},"세":{"docs":{},"스":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"서":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}},"와":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}},"플":{"docs":{},"러":{"docs":{},"그":{"docs":{},"인":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{},"y":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"과":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"이":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}},"레":{"docs":{},"이":{"docs":{},"그":{"docs":{},"라":{"docs":{},"운":{"docs":{},"드":{"docs":{},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}}}}}},"래":{"docs":{},"그":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"랫":{"docs":{},"폼":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},")":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003927729772191673},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0037054191755442334},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0034940600978336828},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"여":{"docs":{},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"t":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"[":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"]":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}}}}}}}}}}}}}}}}},"그":{"docs":{},"렇":{"docs":{},"지":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"게":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"것":{"docs":{},"들":{"docs":{},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"런":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"러":{"docs":{},"나":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"프":{"docs":{},"로":{"docs":{},"젝":{"docs":{},"트":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"퍼":{"docs":{},"티":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"세":{"docs":{},"스":{"docs":{},"가":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}},"향":{"docs":{},"후":{"docs":{},"에":{"docs":{},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"(":{"3":{"docs":{},")":{"docs":{},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"docs":{},"실":{"docs":{},"행":{"docs":{},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"다":{"docs":{},"행":{"docs":{},"히":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"도":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"른":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}},"유":{"docs":{},"효":{"docs":{},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"제":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"것":{"docs":{},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}},"러":{"docs":{},"한":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"렇":{"docs":{},"게":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"에":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"외":{"docs":{},"에":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"출":{"docs":{},"력":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"배":{"docs":{},"열":{"docs":{},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"예":{"docs":{},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"c":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"루":{"docs":{},"프":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}},"메":{"docs":{},"서":{"docs":{},"드":{"docs":{},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"왜":{"docs":{},"냐":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"새":{"docs":{},"로":{"docs":{},"운":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"추":{"docs":{},"상":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}}}},"s":{"docs":{},"x":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"또":{"docs":{},"한":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"앞":{"docs":{},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"즉":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"실":{"docs":{},"수":{"docs":{},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"상":{"docs":{},"황":{"docs":{},"적":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"세":{"docs":{},"가":{"docs":{},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}},"p":{"docs":{},"m":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"너":{"docs":{},"무":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"런":{"docs":{},"타":{"docs":{},"임":{"docs":{},"시":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"일":{"docs":{},"반":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"대":{"docs":{},"부":{"docs":{},"분":{"docs":{},"의":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}},"따":{"docs":{},"라":{"docs":{},"서":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"결":{"docs":{},"과":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"고":{"docs":{},"유":{"docs":{},"하":{"docs":{},"지":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},"최":{"docs":{},"종":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"컴":{"docs":{},"파":{"docs":{},"일":{"docs":{},"러":{"docs":{},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}},"아":{"docs":{},"직":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"(":{"docs":{},"즉":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"집":{"docs":{},"합":{"docs":{},"(":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"성":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"법":{"docs":{},"적":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"형":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"태":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"을":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}},"일":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"가":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"식":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"도":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"성":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"려":{"docs":{},"면":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}},"호":{"docs":{},"출":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.019011406844106463},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}},"하":{"docs":{},"려":{"docs":{},"고":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}},"도":{"docs":{},"록":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"여":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"면":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"기":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"거":{"docs":{},"나":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"할":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.003367003367003367},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"했":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}},"만":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"은":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"한":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"한":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}},"될":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"들":{"docs":{},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"되":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"더":{"docs":{},"라":{"docs":{},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"어":{"docs":{},"야":{"docs":{},"한":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}},"며":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"면":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}}},".":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.011406844106463879},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"이":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"일":{"docs":{},"반":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}}}}}},"된":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"과":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"함":{"docs":{},"으":{"docs":{},"로":{"docs":{},"써":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"환":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"되":{"docs":{},"면":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}},"고":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"지":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"는":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"며":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"것":{"docs":{},"은":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834}}}}},"그":{"docs":{},"러":{"docs":{},"나":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"다":{"docs":{},"른":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"차":{"docs":{},"이":{"docs":{},"점":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"성":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":5}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}}}}}}}}}},"에":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837}}},"은":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}},"을":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.005426356589147287},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"이":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}},"가":{"docs":{},"능":{"docs":{},"한":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"된":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"스":{"docs":{},"팅":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},"부":{"docs":{},"와":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"어":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"활":{"docs":{},"용":{"docs":{},"할":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016835016835016834},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"되":{"docs":{},"어":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"하":{"docs":{},"여":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"보":{"docs":{},"다":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}}},"성":{"docs":{},"화":{"docs":{},"되":{"docs":{},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"하":{"docs":{},"여":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"면":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"세":{"docs":{},"요":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"려":{"docs":{},"면":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"가":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}}}}}},"동":{"docs":{},"이":{"docs":{},"나":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}},"$":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"{":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.005341880341880342}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"}":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"`":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"}":{"docs":{},"!":{"docs":{},"`":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"}":{"docs":{},"`":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"}":{"docs":{},"m":{"docs":{},".":{"docs":{},"`":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"}":{"docs":{},".":{"docs":{},"`":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"}":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"(":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"나":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"*":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004545454545454545},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.005164992826398852},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.004056047197640118},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027223230490018148},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}},"/":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.006825938566552901},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.008985879332477536},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.021671826625386997},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603}}},"]":{"docs":{},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"*":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}},"/":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"=":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"속":{"docs":{},"성":{"docs":{},")":{"docs":{},"가":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"*":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"*":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}}}}}}},"만":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"@":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"{":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}},"t":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.013745704467353952},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"s":{"docs":{},"/":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"l":{"docs":{},"o":{"docs":{},"d":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"/":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"에":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}}}}}}}}}}},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}}}}}}}}},",":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}},",":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}},"{":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}}}}}}}}}}}}}}}},"f":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}},"(":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}}}}}}}}}}}}},"g":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}},"(":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},":":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"e":{"docs":{},"d":{"docs":{},"와":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}},"e":{"docs":{},"d":{"docs":{},"가":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"을":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0034944670937682005}}}}}}},"표":{"docs":{},"현":{"docs":{},"식":{"docs":{},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"a":{"docs":{},"u":{"docs":{},"g":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"]":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.004261363636363636},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},";":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"`":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}}}},"m":{"docs":{},"i":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"e":{"docs":{},"`":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"x":{"docs":{},"`":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}},"`":{"docs":{},"`":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165}},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165}}}}}},"b":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.006021306160259379},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.00250501002004008},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},"e":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}},"t":{"docs":{},"a":{"docs":{},".":{"1":{"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}},"docs":{}},"2":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"docs":{}}},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}},"n":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"e":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"p":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"e":{"docs":{},"r":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},")":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"i":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.01038961038961039},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.04013377926421405},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0925}},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.01038961038961039},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.008528784648187633}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}}}}}}}}}}}}}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"이":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"}":{"docs":{},"'":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}},"을":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},",":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0030959752321981426}}},".":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}},"k":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}}}},"b":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},"`":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0038860103626943004},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}},"p":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"s":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}},"d":{"docs":{},"y":{"docs":{},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"x":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}}}}}},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"문":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.007855459544383346},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.013745704467353952},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0121580547112462}}},"y":{"docs":{},"(":{"docs":{},"{":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"\"":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}},"i":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149}}}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004137931034482759}}}}}}},"j":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"p":{"docs":{},"h":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"e":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.003218390804597701}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}}}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}},"s":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}}}}}}},"에":{"docs":{},"는":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.003629764065335753},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"d":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}},"와":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}}}}}},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.010309278350515464}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},".":{"docs":{},"j":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"s":{"docs":{},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"0":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}},"docs":{}}}}}}}}}}}}}},"g":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003927729772191673}},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"y":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"도":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"은":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"과":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},")":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}},"s":{"docs":{},"e":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0035070140280561123},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"[":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005194805194805195}}}}}}}}},"i":{"docs":{},"c":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"docs":{}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}}},"g":{"docs":{},"s":{"docs":{},")":{"docs":{},"\"":{"docs":{},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"r":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.009067357512953367}},"k":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"와":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},";":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"?":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"(":{"1":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}}},"docs":{},"a":{"docs":{},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},".":{"docs":{},"a":{"docs":{},";":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}}},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}},"c":{"docs":{},"k":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}}}},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"}":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869}}},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}}}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002779064381658175},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167}}},"?":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}},"에":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"{":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"가":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}},"—":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368}}},"교":{"docs":{},"체":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}},"앞":{"docs":{},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}},"환":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"차":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}}}}},"끝":{"docs":{},"난":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"납":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"작":{"docs":{},"성":{"docs":{},"된":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}},"냈":{"docs":{},"나":{"docs":{},"요":{"docs":{},"?":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"없":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"날":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"나":{"docs":{},"면":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"의":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"나":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"열":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"된":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"머":{"docs":{},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"타":{"docs":{},"날":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"납":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"또":{"docs":{},"한":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"(":{"docs":{},"여":{"docs":{},"기":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}},"내":{"docs":{},"기":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"낼":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"냅":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"예":{"docs":{},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"객":{"docs":{},"체":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"이":{"docs":{},"것":{"docs":{},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"t":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}}}}}}}}},"나":{"docs":{},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"중":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"뉩":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},".":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}},"오":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"올":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"갑":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"누":{"docs":{},"어":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"눌":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"옵":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"란":{"docs":{},"히":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"누":{"docs":{},"르":{"docs":{},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}}}},"릴":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"출":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"군":{"docs":{},"가":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"락":{"docs":{},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"데":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.011406844106463879},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"코":{"docs":{},"레":{"docs":{},"이":{"docs":{},"터":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":10.012813046010484},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0052417006406523005}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004076878276062901},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"서":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}},"(":{"docs":{},"@":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.014560279557367502}}},"를":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.005824111822947}}},"와":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"팅":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"된":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"하":{"docs":{},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}},"이":{"docs":{},"터":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0033812341504649195},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"만":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}},"들":{"docs":{},"어":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002300966405890474},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020086083213773313},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}},"가":{"docs":{},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"갑":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.008985879332477536},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}},"있":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"보":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"릴":{"docs":{},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"디":{"docs":{},"버":{"docs":{},"그":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"거":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"가":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}},"깅":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"할":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"렉":{"docs":{},"토":{"docs":{},"리":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0035070140280561123},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"부":{"docs":{},"터":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"서":{"docs":{},"부":{"docs":{},"터":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"내":{"docs":{},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"일":{"docs":{},"때":{"docs":{},"마":{"docs":{},"다":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"와":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"는":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"로":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}},"라":{"docs":{},"이":{"docs":{},"브":{"docs":{},"러":{"docs":{},"리":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.023715415019762844},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"와":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}},"서":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}},"인":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}},"서":{"docs":{},"는":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"이":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"나":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814}}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}},"벨":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"드":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"p":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"하":{"docs":{},"여":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"할":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"되":{"docs":{},"기":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"해":{"docs":{},"야":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}}}},"된":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"컬":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"에":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"서":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"그":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"깅":{"docs":{},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"더":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"보":{"docs":{},"다":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"인":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}}},"들":{"docs":{},"은":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"이":{"docs":{},"며":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"딩":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445}},"과":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"직":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"은":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"케":{"docs":{},"일":{"docs":{},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"먼":{"docs":{},"저":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"메":{"docs":{},"시":{"docs":{},"지":{"docs":{},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"서":{"docs":{},"드":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.005824111822947}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.011406844106463879}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0018407731247123793},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0029615004935834156},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"와":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"로":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}}}}}}}}}}}}}}}}}}}}}}}},"에":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002}},"도":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.022813688212927757}}}}}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"을":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}}},"모":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"이":{"docs":{},"저":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"커":{"docs":{},"니":{"docs":{},"즘":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"의":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"에":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}},"소":{"docs":{},"드":{"docs":{},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}}}},"타":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0064065230052417},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"세":{"docs":{},"지":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}}}},"빌":{"docs":{},"드":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":3.3394123606889563},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":5}},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"한":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"와":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"하":{"docs":{},"는":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}},"는":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"빨":{"docs":{},"간":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}},"선":{"docs":{},"이":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"리":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"서":{"docs":{},"버":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"브":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"타":{"docs":{},"입":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"수":{"docs":{},"(":{"docs":{},"순":{"docs":{},"서":{"docs":{},"가":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}},"비":{"docs":{},"스":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"손":{"docs":{},"쉽":{"docs":{},"게":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"실":{"docs":{},"을":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"스":{"docs":{},"타":{"docs":{},"트":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"일":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"과":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"을":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"크":{"docs":{},"립":{"docs":{},"트":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"가":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"도":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"에":{"docs":{},"서":{"docs":{},"만":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},"의":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},"스":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"코":{"docs":{},"프":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.007874015748031496},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"내":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"에":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"태":{"docs":{},"틱":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0024679170779861796}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"칼":{"docs":{},"라":{"docs":{},"와":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"키":{"docs":{},"마":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"위":{"docs":{},"치":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"아":{"docs":{},"래":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"에":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"서":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"쪽":{"docs":{},"에":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"로":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"직":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},"도":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"닌":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},")":{"docs":{},"인":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},"닙":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"중":{"docs":{},"요":{"docs":{},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"대":{"docs":{},"신":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"'":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"블":{"docs":{},"록":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"형":{"docs":{},"식":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"모":{"docs":{},"듈":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"제":{"docs":{},"공":{"docs":{},"된":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}},"니":{"docs":{},"라":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"고":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},",":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"므":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"면":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"며":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"기":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"마":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"도":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"무":{"docs":{},"렇":{"docs":{},"게":{"docs":{},"나":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"거":{"docs":{},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"런":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"예":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}},"이":{"docs":{},"디":{"docs":{},"어":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"닐":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"티":{"docs":{},"클":{"docs":{},"의":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},"앵":{"docs":{},"귤":{"docs":{},"러":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"업":{"docs":{},"데":{"docs":{},"이":{"docs":{},"트":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"된":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"다":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"할":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"하":{"docs":{},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"여":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"세":{"docs":{},"요":{"docs":{},":":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}}}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}},"그":{"docs":{},"레":{"docs":{},"이":{"docs":{},"드":{"docs":{},"하":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}},"연":{"docs":{},"결":{"docs":{},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"했":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"할":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"되":{"docs":{},"도":{"docs":{},"록":{"docs":{},"하":{"docs":{},"여":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}},"될":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"의":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"하":{"docs":{},"여":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"산":{"docs":{},"자":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"에":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"도":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"어":{"docs":{},"떤":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"의":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},"가":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}},"관":{"docs":{},"된":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}},"유":{"docs":{},"사":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"이":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"트":{"docs":{},"리":{"docs":{},"플":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"게":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"연":{"docs":{},"한":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"하":{"docs":{},"게":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"성":{"docs":{},"을":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"렇":{"docs":{},"게":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}},"용":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"서":{"docs":{},"브":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"f":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"일":{"docs":{},"부":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"하":{"docs":{},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"만":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"게":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"고":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"므":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"한":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},"지":{"docs":{},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"지":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"하":{"docs":{},"려":{"docs":{},"면":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"고":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"거":{"docs":{},"나":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"기":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"지":{"docs":{},"만":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"도":{"docs":{},"록":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"추":{"docs":{},"가":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}},"형":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"화":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}}}},"(":{"docs":{},"예":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"을":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"에":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}},"일":{"docs":{},"한":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"니":{"docs":{},"온":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.003443328550932568}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"으":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"이":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"발":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"효":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"것":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"트":{"docs":{},"리":{"docs":{},"플":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}}}},"한":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"현":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"하":{"docs":{},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"성":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}}}},"래":{"docs":{},"된":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}},"의":{"docs":{},"한":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"해":{"docs":{},"야":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"익":{"docs":{},"하":{"docs":{},"고":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"추":{"docs":{},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"프":{"docs":{},"로":{"docs":{},"퍼":{"docs":{},"티":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}}},"일":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"부":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"만":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"써":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"이":{"docs":{},"며":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"인":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"(":{"docs":{},"개":{"docs":{},"발":{"docs":{},"자":{"docs":{},"에":{"docs":{},"게":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"임":{"docs":{},"에":{"docs":{},"도":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},"련":{"docs":{},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}},"시":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"더":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"반":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}},"적":{"docs":{},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"며":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"지":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"인":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.019851116625310174},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020086083213773313},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.011857707509881422}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"매":{"docs":{},"개":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"일":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"기":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"치":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.011406844106463879},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},"지":{"docs":{},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"도":{"docs":{},"록":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"다":{"docs":{},"면":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"해":{"docs":{},"야":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"렇":{"docs":{},"게":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"단":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"정":{"docs":{},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"관":{"docs":{},"성":{"docs":{},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"된":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"으":{"docs":{},"킬":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"종":{"docs":{},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"회":{"docs":{},"성":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"어":{"docs":{},"날":{"docs":{},"까":{"docs":{},"요":{"docs":{},"?":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}}}}},"나":{"docs":{},"는":{"docs":{},"지":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"대":{"docs":{},"일":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505}}}}},"좋":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"(":{"docs":{},"아":{"docs":{},"래":{"docs":{},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{},"북":{"docs":{},"은":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}}}}},"은":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"아":{"docs":{},"요":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.005426356589147287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.006656804733727811},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.005134788189987163}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00422654268808115},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}},"았":{"docs":{},"어":{"docs":{},"!":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}}}}},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"예":{"docs":{},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"지":{"docs":{},"만":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"준":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"비":{"docs":{},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"됐":{"docs":{},"나":{"docs":{},"요":{"docs":{},"?":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"즉":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"시":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"직":{"docs":{},"접":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"인":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"감":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"적":{"docs":{},"이":{"docs":{},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"관":{"docs":{},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"적":{"docs":{},"인":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},"전":{"docs":{},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0029120559114735}}}},"면":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}},"차":{"docs":{},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"점":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"에":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"가":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"별":{"docs":{},"화":{"docs":{},"된":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"례":{"docs":{},"대":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"용":{"docs":{},"해":{"docs":{},"보":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}},"찾":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}},"나":{"docs":{},"중":{"docs":{},"에":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},"이":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"렇":{"docs":{},"게":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"따":{"docs":{},"라":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}},"은":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"아":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},"냈":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"내":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"보":{"docs":{},"게":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"야":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.00250501002004008},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}},"으":{"docs":{},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"려":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}},"고":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"기":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}},"와":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"게":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"최":{"docs":{},"신":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}}},"상":{"docs":{},"위":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0022123893805309734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}}}},"선":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"종":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064}}},"소":{"docs":{},"한":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"적":{"docs":{},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"화":{"docs":{},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"되":{"docs":{},"고":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"이":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"대":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"취":{"docs":{},"소":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"하":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"급":{"docs":{},"되":{"docs":{},"어":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"힙":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"퀵":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"탐":{"docs":{},"색":{"docs":{},"기":{"docs":{},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}},"태":{"docs":{},"스":{"docs":{},"크":{"docs":{},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"그":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"를":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"로":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"가":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}},"탭":{"docs":{},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"테":{"docs":{},"스":{"docs":{},"트":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"하":{"docs":{},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{},"페":{"docs":{},"이":{"docs":{},"지":{"docs":{},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}},"여":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"할":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"새":{"docs":{},"로":{"docs":{},"운":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}},"폴":{"docs":{},"더":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}},"항":{"docs":{},"목":{"docs":{},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"으":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"상":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"후":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}},"위":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"의":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"행":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"보":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.007444168734491315}}}},"~":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"/":{"docs":{},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"/":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}}}}}}}}},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}}}}}}}}}},"└":{"docs":{},"─":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}},"─":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.00501002004008016}},"─":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}},"├":{"docs":{},"─":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"─":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064}},"─":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}},"걸":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"프":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":10}},",":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"쳐":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"있":{"docs":{},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"맞":{"docs":{},"은":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"음":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"고":{"docs":{},"침":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"급":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":5.000286944045911},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},"스":{"docs":{},"럽":{"docs":{},"게":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},"정":{"docs":{},"된":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"시":{"docs":{},"킬":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"려":{"docs":{},"해":{"docs":{},"야":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"여":{"docs":{},"기":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}}}}}},"보":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},"또":{"docs":{},"한":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"빌":{"docs":{},"드":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}},"하":{"docs":{},"고":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"세":{"docs":{},"요":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"되":{"docs":{},"지":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"이":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}},"했":{"docs":{},"으":{"docs":{},"며":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"맙":{"docs":{},"게":{"docs":{},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"통":{"docs":{},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"었":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"스":{"docs":{},"럽":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"다":{"docs":{},"행":{"docs":{},"스":{"docs":{},"럽":{"docs":{},"게":{"docs":{},"도":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}}}}}},"유":{"docs":{},"한":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855}},"인":{"docs":{},"터":{"docs":{},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}}}},"해":{"docs":{},"야":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},"전":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"쳐":{"docs":{},"야":{"docs":{},"하":{"docs":{},"는":{"docs":{},"지":{"docs":{},".":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}}}}},"골":{"docs":{},"격":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},"광":{"docs":{},"범":{"docs":{},"위":{"docs":{},"한":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"하":{"docs":{},"게":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}},"글":{"docs":{},"로":{"docs":{},"벌":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},"에":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"난":{"docs":{},"독":{"docs":{},"화":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"넣":{"docs":{},"으":{"docs":{},"면":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"어":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"야":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"노":{"docs":{},"드":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}}},".":{"docs":{},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"력":{"docs":{},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"하":{"docs":{},"고":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"트":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"출":{"docs":{},"된":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"다":{"docs":{},"시":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"되":{"docs":{},"지":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"하":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}},"당":{"docs":{},"장":{"docs":{},"은":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"신":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}},"연":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"대":{"docs":{},"부":{"docs":{},"분":{"docs":{},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}}},"돌":{"docs":{},"아":{"docs":{},"가":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"와":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"둘":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"째":{"docs":{},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"은":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"루":{"docs":{},"트":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.003409090909090909}}},"가":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"임":{"docs":{},"을":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"프":{"docs":{},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.011111111111111112}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}}},"맞":{"docs":{},"춤":{"docs":{},"형":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"추":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"고":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}}}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"게":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"닥":{"docs":{},"뜨":{"docs":{},"리":{"docs":{},"면":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}},"맵":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}}},"이":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"과":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"으":{"docs":{},"로":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"핑":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"이":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"묶":{"docs":{},"어":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"야":{"docs":{},"한":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}}},"인":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"믹":{"docs":{},"스":{"docs":{},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"인":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":10.01038961038961}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"서":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"으":{"docs":{},"로":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"을":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.007792207792207792}}},"의":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.01038961038961039}}},"이":{"docs":{},"나":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}},"싱":{"docs":{},"하":{"docs":{},"여":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}},"받":{"docs":{},"게":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}},"아":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"들":{"docs":{},"일":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"백":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"그":{"docs":{},"라":{"docs":{},"운":{"docs":{},"드":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"틱":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844}}}}}}}}}},"별":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"도":{"docs":{},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"로":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"칭":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},")":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"(":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}},"종":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"개":{"docs":{},"의":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"이":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}},"세":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002}},"부":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"이":{"docs":{},"프":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"쉬":{"docs":{},"운":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"워":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"압":{"docs":{},"축":{"docs":{},"되":{"docs":{},"는":{"docs":{},"지":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"하":{"docs":{},"기":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"앞":{"docs":{},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"약":{"docs":{},"간":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"엉":{"docs":{},"망":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"원":{"docs":{},"본":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.003875968992248062},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"과":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"대":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"기":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"래":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"천":{"docs":{},"이":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"치":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"인":{"docs":{},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}},"칙":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"다":{"docs":{},"면":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"리":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"활":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"했":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"할":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"시":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},"적":{"docs":{},"인":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"점":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"차":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"진":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}},",":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"이":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"다":{"docs":{},".":{"docs":{},"그":{"docs":{},"리":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"프":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"것":{"docs":{},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}},"접":{"docs":{},"근":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}},"할":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"하":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"여":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"기":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"자":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0014807502467917078}},"가":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"인":{"docs":{},"스":{"docs":{},"턴":{"docs":{},"스":{"docs":{},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}},"으":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"법":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"제":{"docs":{},"어":{"docs":{},"자":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0064065230052417}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"를":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"게":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}},"두":{"docs":{},"사":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"어":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}},"했":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"해":{"docs":{},"봤":{"docs":{},"다":{"docs":{},"면":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}},"미":{"docs":{},"사":{"docs":{},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"존":{"docs":{},"재":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064}},"이":{"docs":{},"러":{"docs":{},"한":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}},"경":{"docs":{},"로":{"docs":{},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}},"하":{"docs":{},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"거":{"docs":{},"나":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"기":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"할":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"한":{"docs":{},"다":{"docs":{},"고":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}},"처":{"docs":{},"리":{"docs":{},"하":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"고":{"docs":{},"자":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"된":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}},")":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"한":{"docs":{},"다":{"docs":{},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"되":{"docs":{},"고":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"될":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"음":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"럼":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"출":{"docs":{},"력":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.004180602006688963},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"과":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"은":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},"이":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"서":{"docs":{},"는":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},"!":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705}}}}}},"하":{"docs":{},"도":{"docs":{},"록":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"된":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"발":{"docs":{},"점":{"docs":{},"이":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}},"콘":{"docs":{},"솔":{"docs":{},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"텍":{"docs":{},"스":{"docs":{},"트":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},"튜":{"docs":{},"토":{"docs":{},"리":{"docs":{},"얼":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"플":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"이":{"docs":{},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"따":{"docs":{},"라":{"docs":{},"서":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}},"!":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"으":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"음":{"docs":{},"에":{"docs":{},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"던":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"다":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"!":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"[":{"1":{"docs":{},"]":{"docs":{},")":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"=":{"docs":{},"=":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}}}}},"&":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":3.333333333333333},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011477761836441894},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"&":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0018148820326678765}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"x":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.003242241778601204},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.006896551724137931},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.009925558312655087},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.006201550387596899},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020086083213773313},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0022123893805309734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.006825938566552901},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0038510911424903724},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.003629764065335753},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.015544041450777202}},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.006191950464396285},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.009067357512953367}}},"[":{"3":{"docs":{},"]":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"6":{"docs":{},"]":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"docs":{}},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002779064381658175},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837}}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}}}}},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"docs":{},"\"":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"f":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}}}}}}}}}}}}}},"z":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}}}},"가":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}},"에":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}},"(":{"4":{"2":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}},"docs":{}},"docs":{},"y":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},";":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0046439628482972135}}}},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}}}}}},"m":{"docs":{},"l":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"y":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.004651162790697674},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.003629764065335753},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0051813471502590676}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0029615004935834156},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002758620689655172},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0051813471502590676}}},"e":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}},"a":{"docs":{},"r":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}}}},"h":{"docs":{},"u":{"docs":{},"d":{"docs":{},"a":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.003875968992248062}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0036781609195402297},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.003875968992248062},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}}},"?":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"가":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}},"에":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"서":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}},"와":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"의":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"o":{"docs":{},"u":{"docs":{},"'":{"docs":{},"r":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}},"l":{"docs":{},"l":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0054446460980036296},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},"d":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},"r":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}}}}},"’":{"docs":{},"l":{"docs":{},"l":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}},"r":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}},"v":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}}}}}},"(":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"docs":{},"\"":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}}}}}}}}}},"|":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0033812341504649195},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.013773314203730272},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0042643923240938165},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"|":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014347202295552368},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}},"│":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0045090180360721445}}},"각":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0024679170779861796},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0031007751937984496},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00331858407079646},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.005341880341880342},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.002004008016032064},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00441306266548985},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0034944670937682005},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"각":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"에":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"기":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"값":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0033812341504649195},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005917159763313609},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408}},"서":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"만":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00507185122569738},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0020964360587002098},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020086083213773313},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002}}},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"이":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.00253592561284869},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0045662100456621},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"기":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855}},"이":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"즉":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"과":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"들":{"docs":{},"을":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"으":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"네":{"docs":{},"임":{"docs":{},"스":{"docs":{},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}},"도":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"갖":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}},"\"":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"와":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}},"지":{"docs":{},"원":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"춰":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"게":{"docs":{},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"춘":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"도":{"docs":{},"록":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"걱":{"docs":{},"정":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"하":{"docs":{},"지":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}},"곳":{"docs":{},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"라":{"docs":{},"면":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"과":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"을":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"은":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"관":{"docs":{},"대":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"한":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"리":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"프":{"docs":{},"로":{"docs":{},"젝":{"docs":{},"트":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}},"에":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"되":{"docs":{},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"해":{"docs":{},"야":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}},"하":{"docs":{},"는":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"계":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},"없":{"docs":{},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"시":{"docs":{},"키":{"docs":{},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"의":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"련":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"된":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"하":{"docs":{},"여":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}}}},")":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"사":{"docs":{},"항":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"심":{"docs":{},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"점":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}}},"찰":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}}},"하":{"docs":{},"거":{"docs":{},"나":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}},"할":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"꽤":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"너":{"docs":{},"무":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002758620689655172},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}},"나":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"높":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"일":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"다":{"docs":{},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"은":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"느":{"docs":{},"껴":{"docs":{},"질":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"슨":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"낄":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"덜":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"어":{"docs":{},"주":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"덮":{"docs":{},"어":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"쓰":{"docs":{},"기":{"docs":{},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"씁":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"따":{"docs":{},"라":{"docs":{},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}},"씌":{"docs":{},"웁":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}}}}}}}}}},"된":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"다":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}}}}},"뒤":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"있":{"docs":{},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"뛰":{"docs":{},"어":{"docs":{},"난":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"레":{"docs":{},"벨":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867}},"서":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"이":{"docs":{},"거":{"docs":{},"나":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"이":{"docs":{},"아":{"docs":{},"웃":{"docs":{},"과":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"블":{"docs":{},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"말":{"docs":{},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"하":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"자":{"docs":{},"면":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"해":{"docs":{},"줍":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"아":{"docs":{},"야":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}},"무":{"docs":{},"언":{"docs":{},"가":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"엇":{"docs":{},"인":{"docs":{},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}},"이":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"었":{"docs":{},"는":{"docs":{},"지":{"docs":{},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}},"입":{"docs":{},"니":{"docs":{},"까":{"docs":{},"?":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"\"":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}},"일":{"docs":{},"까":{"docs":{},"요":{"docs":{},"?":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}},"슨":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"시":{"docs":{},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"새":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}}},"하":{"docs":{},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"덤":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"단":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"한":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"입":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"상":{"docs":{},"태":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036}}}}},"묵":{"docs":{},"시":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"물":{"docs":{},"론":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"건":{"docs":{},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"리":{"docs":{},"적":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"반":{"docs":{},"환":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0033812341504649195},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.002315886984715146},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0027611596870685687},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004137931034482759},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0034940600978336828},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}},"문":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"상":{"docs":{},"황":{"docs":{},"적":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}}}}}}},"되":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"하":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0076045627376425855},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002}}},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"거":{"docs":{},"나":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"기":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"도":{"docs":{},"록":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"된":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"한":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}},"사":{"docs":{},"용":{"docs":{},"자":{"docs":{},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},"숫":{"docs":{},"자":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}},"될":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"할":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"횔":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"했":{"docs":{},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"값":{"docs":{},"이":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"드":{"docs":{},"시":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"대":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"배":{"docs":{},"열":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}},"일":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"복":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"마":{"docs":{},"다":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}},"문":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}},"자":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}},"를":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}},"는":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}},"되":{"docs":{},"는":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408}}}},"하":{"docs":{},"며":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"반":{"docs":{},"복":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}}}}},"해":{"docs":{},"서":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}},"면":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"영":{"docs":{},"되":{"docs":{},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"하":{"docs":{},"기":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"벅":{"docs":{},"차":{"docs":{},"다":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"베":{"docs":{},"이":{"docs":{},"스":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"에":{"docs":{},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}},"병":{"docs":{},"합":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":5.006178287731686}},"하":{"docs":{},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"기":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}},"려":{"docs":{},"면":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},"되":{"docs":{},"어":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"야":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"지":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"며":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"된":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0088261253309797}}},"될":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"\"":{"docs":{},"은":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"'":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}},"그":{"docs":{},"러":{"docs":{},"나":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},"은":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}},"을":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00441306266548985}}},"이":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"가":{"docs":{},"장":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}},"할":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00264783759929391}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"네":{"docs":{},"임":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}}}}},"비":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.003006012024048096},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"밀":{"docs":{},"스":{"docs":{},"러":{"docs":{},"운":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"롯":{"docs":{},"될":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"된":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"슷":{"docs":{},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"게":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"한":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},".":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"제":{"docs":{},"네":{"docs":{},"릭":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}},")":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"구":{"docs":{},"조":{"docs":{},"화":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.003242241778601204}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"된":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"시":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"전":{"docs":{},"체":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"처":{"docs":{},"럼":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"하":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}},"해":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"교":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}},"하":{"docs":{},"며":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}},"할":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"정":{"docs":{},"적":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}},"적":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"상":{"docs":{},"수":{"docs":{},"(":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}},"대":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"앰":{"docs":{},"비":{"docs":{},"언":{"docs":{},"트":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}},"용":{"docs":{},"을":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"례":{"docs":{},"해":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"어":{"docs":{},"있":{"docs":{},"을":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"워":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}},"활":{"docs":{},"성":{"docs":{},"화":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}}}}}}}},"빼":{"docs":{},"먹":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"뻬":{"docs":{},"먹":{"docs":{},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"뼈":{"docs":{},"대":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"살":{"docs":{},"펴":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"보":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"새":{"docs":{},"로":{"docs":{},"운":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}}},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"세":{"docs":{},"요":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"았":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"것":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}},"면":{"docs":{},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"봅":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"그":{"docs":{},"러":{"docs":{},"나":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"시":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}},"본":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"성":{"docs":{},"공":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}},"하":{"docs":{},"면":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}},"능":{"docs":{},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"가":{"docs":{},"시":{"docs":{},"게":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}},"숫":{"docs":{},"자":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.011872146118721462},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},"여":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"형":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"(":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}}}}}},"나":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}},"인":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"와":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"/":{"docs":{},"문":{"docs":{},"자":{"docs":{},"열":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"쉽":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"암":{"docs":{},"시":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"으":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"될":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"한":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}}},"얻":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"실":{"docs":{},"제":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"으":{"docs":{},"나":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"생":{"docs":{},"성":{"docs":{},"자":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}},"고":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"엄":{"docs":{},"격":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"함":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"모":{"docs":{},"드":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"열":{"docs":{},"거":{"docs":{},"형":{"docs":{},"의":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}}},"밀":{"docs":{},"히":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"염":{"docs":{},"두":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"옮":{"docs":{},"기":{"docs":{},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"깁":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}},"옳":{"docs":{},"다":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"읽":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"어":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948}},"볼":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"보":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}},"y":{"docs":{},"e":{"docs":{},"h":{"docs":{},"u":{"docs":{},"d":{"docs":{},"a":{"docs":{},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}}}}},"야":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}},"하":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}}}},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"거":{"docs":{},"나":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"었":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"지":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}},"잃":{"docs":{},"어":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"버":{"docs":{},"린":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"리":{"docs":{},"지":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"립":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"만":{"docs":{},"약":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"잡":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"아":{"docs":{},"내":{"docs":{},"지":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"을":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"장":{"docs":{},"기":{"docs":{},"적":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"인":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"에":{"docs":{},"서":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543}}}}},"점":{"docs":{},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"소":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"애":{"docs":{},"와":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"조":{"docs":{},"금":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"작":{"docs":{},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"절":{"docs":{},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}},"차":{"docs":{},"도":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"심":{"docs":{},"히":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"치":{"docs":{},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"건":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"을":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"에":{"docs":{},"서":{"docs":{},"만":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"부":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"용":{"docs":{},"히":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"합":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"으":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"각":{"docs":{},"은":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"직":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}},"으":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"회":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"할":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}},"좀":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"종":{"docs":{},"류":{"docs":{},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"인":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"에":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"일":{"docs":{},"뿐":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"속":{"docs":{},"성":{"docs":{},"을":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"종":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"료":{"docs":{},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"즐":{"docs":{},"겁":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"겨":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"집":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"합":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},".":{"docs":{},"표":{"docs":{},"현":{"docs":{},"식":{"docs":{},"은":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}},"으":{"docs":{},"로":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"인":{"docs":{},"것":{"docs":{},"처":{"docs":{},"럼":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"철":{"docs":{},"자":{"docs":{},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"저":{"docs":{},"한":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"히":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"체":{"docs":{},"크":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"하":{"docs":{},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"!":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"커":{"docs":{},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"에":{"docs":{},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"킹":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"계":{"docs":{},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"를":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"인":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"으":{"docs":{},"로":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}},"충":{"docs":{},"분":{"docs":{},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"족":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"도":{"docs":{},"록":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"시":{"docs":{},"키":{"docs":{},"기":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"킵":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"비":{"docs":{},"록":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}}}}}},"돌":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"된":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"은":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"에":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"트":{"docs":{},"랜":{"docs":{},"스":{"docs":{},"파":{"docs":{},"일":{"docs":{},"러":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},"렌":{"docs":{},"드":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"리":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"플":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":3.351663272233537},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}}},"특":{"docs":{},"별":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"즉":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"한":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"하":{"docs":{},"게":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"정":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"히":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"성":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"에":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"화":{"docs":{},"된":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"수":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"한":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"화":{"docs":{},"된":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}}}},"징":{"docs":{},"은":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"틀":{"docs":{},"리":{"docs":{},"거":{"docs":{},"나":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"판":{"docs":{},"결":{"docs":{},"났":{"docs":{},"다":{"docs":{},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"단":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"되":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"하":{"docs":{},"는":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928}}}}}},"평":{"docs":{},"범":{"docs":{},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"가":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}},"되":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"어":{"docs":{},"야":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"될":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"할":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"핸":{"docs":{},"드":{"docs":{},"북":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"들":{"docs":{},"러":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"링":{"docs":{},"하":{"docs":{},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"허":{"docs":{},"용":{"docs":{},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},":":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}},"해":{"docs":{},"준":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"와":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}}}}}}}}}}}},"되":{"docs":{},"며":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"하":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"만":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}},"지":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}},"됨":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"된":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"혜":{"docs":{},"택":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"혹":{"docs":{},"시":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"은":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"훨":{"docs":{},"씬":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},";":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603}}},"_":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"와":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}},"와":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}}}}}},"i":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007407407407407408}}},"p":{"0":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}},"1":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}},"docs":{}},"x":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"y":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},".":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.006993006993006993}},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.013986013986013986}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"r":{"docs":{},"k":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0021321961620469083}}}}}}}}},"겁":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}},"특":{"docs":{},"정":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}}},"먹":{"docs":{},"지":{"docs":{},"마":{"docs":{},"세":{"docs":{},"요":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}},"궁":{"docs":{},"금":{"docs":{},"해":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"달":{"docs":{},"리":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},")":{"docs":{},".":{"docs":{},"예":{"docs":{},"를":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}},"아":{"docs":{},"야":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}},"라":{"docs":{},"집":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"러":{"docs":{},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"성":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"담":{"docs":{},"은":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"당":{"docs":{},"한":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}},"독":{"docs":{},"립":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"으":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"된":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"자":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"빠":{"docs":{},"르":{"docs":{},"게":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"뿐":{"docs":{},"이":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"어":{"docs":{},"떠":{"docs":{},"한":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}},"만":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"싶":{"docs":{},"다":{"docs":{},"면":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}},"을":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"임":{"docs":{},"포":{"docs":{},"트":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"몇":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"와":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"증":{"docs":{},"가":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"즉":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}},"함":{"docs":{},"에":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"명":{"docs":{},"할":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"채":{"docs":{},"우":{"docs":{},"기":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"만":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}}},"게":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"워":{"docs":{},"진":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"택":{"docs":{},"되":{"docs":{},"도":{"docs":{},"록":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"면":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"캐":{"docs":{},"시":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0022727272727272726}}}},"흔":{"docs":{},"치":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0011363636363636363}}},"한":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"히":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"강":{"docs":{},"력":{"docs":{},"한":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"하":{"docs":{},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"요":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"문":{"docs":{},"자":{"docs":{},"열":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}}}},"제":{"docs":{},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"로":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}},"과":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"정":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"도":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"권":{"docs":{},"장":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505}},"하":{"docs":{},"지":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"되":{"docs":{},"지":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"꺼":{"docs":{},"져":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"논":{"docs":{},"의":{"docs":{},"하":{"docs":{},"겠":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},"할":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}},"리":{"docs":{},"적":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505}},"으":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"던":{"docs":{},"지":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"질":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"런":{"docs":{},"타":{"docs":{},"임":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.003006012024048096},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004659289458357601},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"시":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},"의":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}},"멤":{"docs":{},"버":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.005479452054794521},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00794351279788173},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0029615004935834156},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.005590496156533892},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"들":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},"은":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0019743336623889436},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.010483401281304601},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"만":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}},"이":{"docs":{},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"며":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"조":{"docs":{},"차":{"docs":{},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.01004566210045662},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00441306266548985}}},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.005479452054794521},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004076878276062901}}},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}}},"와":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"리":{"docs":{},"터":{"docs":{},"럴":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}},"만":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015503875968992248}}},"을":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"미":{"docs":{},"치":{"docs":{},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"는":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"지":{"docs":{},"를":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}},"리":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"래":{"docs":{},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"묘":{"docs":{},"한":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"하":{"docs":{},"며":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"칩":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"믿":{"docs":{},"어":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"본":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"문":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0025673940949935813}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"이":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"질":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}},"쌍":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"써":{"docs":{},"드":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"놓":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"엔":{"docs":{},"티":{"docs":{},"티":{"docs":{},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},"진":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}},"에":{"docs":{},"서":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}},"을":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}},"역":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401}},"할":{"docs":{},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.004073319755600814}}}},"매":{"docs":{},"핑":{"docs":{},"을":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"방":{"docs":{},"향":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}}}}}}}},"영":{"docs":{},"향":{"docs":{},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"받":{"docs":{},"지":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"은":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}},"외":{"docs":{},"부":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}},"에":{"docs":{},"도":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0036529680365296802},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}},"닉":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"재":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"구":{"docs":{},"성":{"docs":{},"하":{"docs":{},"지":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}},"선":{"docs":{},"언":{"docs":{},"과":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"할":{"docs":{},"당":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"사":{"docs":{},"용":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}},"하":{"docs":{},"기":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},",":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"귀":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}},"빠":{"docs":{},"르":{"docs":{},"게":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"정":{"docs":{},"의":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"순":{"docs":{},"환":{"docs":{},"성":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}}}}}}},"절":{"docs":{},"대":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0016906170752324597}}},"적":{"docs":{},"인":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}},"충":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"좁":{"docs":{},"혀":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}},"지":{"docs":{},"더":{"docs":{},"라":{"docs":{},"도":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}}},"히":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}},"친":{"docs":{},"숙":{"docs":{},"한":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}},"컨":{"docs":{},"텐":{"docs":{},"츠":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"가":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"텍":{"docs":{},"스":{"docs":{},"트":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0023296447291788003}},"에":{"docs":{},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}},"(":{"docs":{},"예":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"벤":{"docs":{},"션":{"docs":{},"을":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"쿼":{"docs":{},"트":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}},"리":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}},"와":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"큰":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"템":{"docs":{},"플":{"docs":{},"릿":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"왜":{"docs":{},"냐":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}}}},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"에":{"docs":{},"서":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}}},"현":{"docs":{},"재":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.002840909090909091},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"대":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"혼":{"docs":{},"재":{"docs":{},"되":{"docs":{},"어":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}},"동":{"docs":{},"되":{"docs":{},"어":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"을":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"란":{"docs":{},"스":{"docs":{},"러":{"docs":{},"워":{"docs":{},"지":{"docs":{},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"움":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"럽":{"docs":{},"겠":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"이":{"docs":{},"름":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}},"고":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}},"자":{"docs":{},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"합":{"docs":{},"될":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}},"화":{"docs":{},"살":{"docs":{},"표":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002758620689655172}},"(":{"docs":{},"=":{"docs":{},">":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}},"획":{"docs":{},"득":{"docs":{},"하":{"docs":{},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0008453085376162299}}}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.016272189349112426}}},"k":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.003436426116838488}},"w":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"(":{"docs":{},"w":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}}}}}}},"y":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0025906735751295338}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}},"e":{"docs":{},"v":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"o":{"docs":{},"f":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.004591104734576757}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"와":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}},"s":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"]":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"y":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0013895321908290875}}}},"u":{"docs":{},"m":{"docs":{},"l":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}}}},"n":{"docs":{},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.003629764065335753},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}}}}}},"a":{"docs":{},"t":{"docs":{},"z":{"docs":{},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}},")":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"[":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"]":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}},"n":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.0038022813688212928},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0009074410163339383}}}}}},".":{"docs":{},"d":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713}}}}}}}}}}}}}}}}},"o":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"z":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0018264840182648401},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.007772020725388601}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}},"o":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.004962779156327543}},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"e":{"docs":{},"r":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}},":":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009871668311944718}}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}}}},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}}}}},"]":{"docs":{},"+":{"docs":{},"$":{"docs":{},"/":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}}}}}},"a":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}}},"c":{"docs":{},"v":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}},"i":{"docs":{},"p":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0018436578171091445}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.004424778761061947},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},".":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},".":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0014749262536873156},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}}}}}}}}}}}},")":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0012953367875647669}}},"h":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}},"건":{"docs":{},"너":{"docs":{},"뛸":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"뜁":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"뛰":{"docs":{},"기":{"docs":{},"[":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}},"괄":{"docs":{},"호":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"(":{"docs":{},"<":{"docs":{},">":{"docs":{},")":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"근":{"docs":{},"본":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"깊":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"숙":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"이":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007905138339920948}}}},"이":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"까":{"docs":{},"다":{"docs":{},"로":{"docs":{},"울":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"네":{"docs":{},"이":{"docs":{},"밍":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"은":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"티":{"docs":{},"브":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"임":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0088261253309797}},"스":{"docs":{},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":10.007478632478632},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.006825938566552901},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00441306266548985}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00353045013239188},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}},"서":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.005119453924914676}},"만":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":5.006825938566553},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"(":{"docs":{},"이":{"docs":{},"전":{"docs":{},"의":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}},"의":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}}}}}}}},"트":{"docs":{},"워":{"docs":{},"크":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"가":{"docs":{},"지":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}}}},"놀":{"docs":{},"라":{"docs":{},"운":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"랐":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002795248078266946},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.00821917808219178},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"s":{"docs":{},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{},".":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.003703703703703704}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"x":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}}}}}}}}}}}}}}}}}}},"뜻":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"인":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"렉":{"docs":{},"시":{"docs":{},"컬":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"멈":{"docs":{},"추":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"지":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}},"묻":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"것":{"docs":{},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}},"밀":{"docs":{},"리":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"접":{"docs":{},"한":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"블":{"docs":{},"럭":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"록":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.005094951366373321}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"처":{"docs":{},"럼":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"랙":{"docs":{},"박":{"docs":{},"스":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"쓸":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0018527095877721167}}},"악":{"docs":{},"화":{"docs":{},"시":{"docs":{},"키":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"명":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"양":{"docs":{},"날":{"docs":{},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"식":{"docs":{},"에":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"얕":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"왜":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}},"냐":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}},"왼":{"docs":{},"쪽":{"docs":{},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001721664275466284}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}}}},"으":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"익":{"docs":{},"숙":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}},"하":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"게":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}},"다":{"docs":{},"면":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"해":{"docs":{},"지":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"게":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}},"할":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"명":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}},"의":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"으":{"docs":{},"로":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}},"잠":{"docs":{},"깐":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"좌":{"docs":{},"절":{"docs":{},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"질":{"docs":{},"문":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"들":{"docs":{},"과":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"은":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"챕":{"docs":{},"터":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"캡":{"docs":{},"쳐":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}},"된":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"링":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"하":{"docs":{},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"했":{"docs":{},"으":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}},"처":{"docs":{},"된":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"하":{"docs":{},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"여":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"할":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}}}}},"콜":{"docs":{},"론":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0009263547938860583}}}},"백":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}},"에":{"docs":{},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.002325581395348837}}}}},"팀":{"docs":{},"원":{"docs":{},"들":{"docs":{},"과":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}},"횟":{"docs":{},"수":{"docs":{},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"흐":{"docs":{},"름":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}},"흭":{"docs":{},"득":{"docs":{},"하":{"docs":{},"였":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}}}}}}}}},"힘":{"docs":{},"든":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0004631773969430292}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"들":{"docs":{},"기":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"?":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0015479876160990713},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"거":{"docs":{},"치":{"docs":{},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}},"칩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"객":{"docs":{},"체":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}},"에":{"docs":{},"요":{"docs":{},"!":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"슬":{"docs":{},"러":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"칠":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"쳐":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}},"괜":{"docs":{},"찮":{"docs":{},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"을":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"금":{"docs":{},"지":{"docs":{},"되":{"docs":{},"어":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}}},"되":{"docs":{},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717}}},"기":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"므":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}},"고":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}}}}}}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0009203865623561896},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0024813895781637717},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001503006012024048}},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}},"일":{"docs":{},"드":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}},"카":{"docs":{},"드":{"docs":{},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014204545454545455}}}}}}},"치":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"하":{"docs":{},"여":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"측":{"docs":{},"면":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}},"에":{"docs":{},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"만":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013805798435342844},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473}},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}},"서":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"풍":{"docs":{},"부":{"docs":{},"한":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948}}}}},"핵":{"docs":{},"심":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004601932811780948},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"삭":{"docs":{},"제":{"docs":{},"했":{"docs":{},"는":{"docs":{},"지":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}}}},"슈":{"docs":{},"퍼":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"왔":{"docs":{},"는":{"docs":{},"지":{"docs":{},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}}},"기":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"응":{"docs":{},"용":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359}}}},"줍":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0004935834155972359},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.003205128205128205}},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{},"의":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}}}}}}},"%":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022988505747126436}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}},"이":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}},"굵":{"docs":{},"은":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"남":{"docs":{},"겨":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}},"졌":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}},"진":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"놨":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}}}}},"아":{"docs":{},"있":{"docs":{},"어":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}},"넘":{"docs":{},"겨":{"docs":{},"주":{"docs":{},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"줄":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"기":{"docs":{},"면":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"길":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}},"덱":{"docs":{},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0009195402298850574}}}},"돕":{"docs":{},"기":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"드":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"문":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}},"물":{"docs":{},"기":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"듭":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"특":{"docs":{},"히":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}},"딱":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001379310344827586}}},"벗":{"docs":{},"어":{"docs":{},"나":{"docs":{},"지":{"docs":{},"만":{"docs":{},"캡":{"docs":{},"처":{"docs":{},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}}},"신":{"docs":{},"호":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}},"경":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"중":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"히":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"뢰":{"docs":{},"할":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"얼":{"docs":{},"마":{"docs":{},"나":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}},"카":{"docs":{},"드":{"docs":{},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0018390804597701149}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.001002004008016032}}}}},"효":{"docs":{},"과":{"docs":{},"적":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"때":{"docs":{},"문":{"docs":{},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0004597701149425287}}}}}}}}},"으":{"docs":{},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}},"<":{"docs":{},">":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"길":{"docs":{},"이":{"docs":{},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}},"꺾":{"docs":{},"쇠":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.001397624039133473},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0014792899408284023}}}},"눈":{"docs":{},"치":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"삽":{"docs":{},"입":{"docs":{},"해":{"docs":{},"야":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}},"하":{"docs":{},"는":{"docs":{},"지":{"docs":{},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}}}}}},"하":{"docs":{},"여":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"할":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"짧":{"docs":{},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}},"은":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}},"챘":{"docs":{},"을":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365}}}},"팩":{"docs":{},"토":{"docs":{},"리":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0022189349112426036},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0006988120195667365},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017472335468841002}}},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}},".":{"docs":{},"@":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}}}}}}}}}}}}}}},"^":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}},"떄":{"docs":{},"문":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}},"섞":{"docs":{},"일":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}},"앰":{"docs":{},"비":{"docs":{},"언":{"docs":{},"트":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0027397260273972603}}}}}},"엑":{"docs":{},"섹":{"docs":{},"스":{"docs":{},"하":{"docs":{},"고":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0009132420091324201}}}}}}}},"숨":{"docs":{},"겨":{"docs":{},"진":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}}},"식":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}}},"별":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.000860832137733142}},"자":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"에":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}},"하":{"docs":{},"기":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},",":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}}}},"용":{"docs":{},"어":{"docs":{},"가":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007751937984496124}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0007374631268436578},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.002136752136752137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0034129692832764505}}},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}},"겹":{"docs":{},"칠":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"굉":{"docs":{},"장":{"docs":{},"히":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"낸":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}},"래":{"docs":{},"핑":{"docs":{},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"하":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}},"막":{"docs":{},"대":{"docs":{},"(":{"docs":{},"|":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}}},"싱":{"docs":{},"글":{"docs":{},"톤":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005738880918220947}}}}},"잊":{"docs":{},"어":{"docs":{},"버":{"docs":{},"렸":{"docs":{},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"리":{"docs":{},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}}}}},"켜":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}}},"토":{"docs":{},"니":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00028694404591104734}}},"큰":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"넓":{"docs":{},"은":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"워":{"docs":{},"크":{"docs":{},"플":{"docs":{},"로":{"docs":{},"우":{"docs":{},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}}}}},"찍":{"docs":{},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}},"컬":{"docs":{},"렉":{"docs":{},"션":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"헬":{"docs":{},"퍼":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0011061946902654867},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"훌":{"docs":{},"륭":{"docs":{},"한":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0003687315634218289}}}}},"게":{"docs":{},"시":{"docs":{},"물":{"docs":{},"은":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}}}},"머":{"docs":{},"리":{"docs":{},"말":{"docs":{},"에":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}},"앨":{"docs":{},"리":{"docs":{},"어":{"docs":{},"싱":{"docs":{},"된":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010683760683760685}}}}}}},"격":{"docs":{},"리":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0017064846416382253}}}},"#":{"1":{"2":{"3":{"2":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"docs":{}},"docs":{}},"docs":{}},"2":{"5":{"7":{"7":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"{":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"}":{"docs":{},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}}},"“":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"”":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"”":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}}}}}},"국":{"docs":{},"제":{"docs":{},"화":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}},"뷰":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"옆":{"docs":{},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}},"줌":{"docs":{},"으":{"docs":{},"로":{"docs":{},"써":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.000501002004008016}}}}}},"맨":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}},"숙":{"docs":{},"제":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00176522506619594}},"로":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00088261253309797}}}},"련":{"docs":{},"자":{"docs":{},"들":{"docs":{},"을":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003952569169960474}}}}}}},"똑":{"docs":{},"같":{"docs":{},"이":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}},"회":{"docs":{},"상":{"docs":{},"해":{"docs":{},"봅":{"docs":{},"시":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}}}},"피":{"docs":{},"하":{"docs":{},"고":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}}},"흥":{"docs":{},"미":{"docs":{},"로":{"docs":{},"운":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0007396449704142012}}}}}},"∘":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}},"뭐":{"docs":{},"든":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0011648223645894002}}}},"봉":{"docs":{},"인":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"다":{"docs":{},"음":{"docs":{},"은":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}}}}}}}},"첨":{"docs":{},"부":{"docs":{},"될":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005824111822947001}}}}},"능":{"docs":{},"력":{"docs":{},"에":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0025974025974025974}}}}},"슬":{"docs":{},"래":{"docs":{},"시":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":3.3557365919891375},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"는":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.002036659877800407}}}}}},"닫":{"docs":{},"힌":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0012836970474967907}}}},"►":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.03511705685618729}}},"색":{"docs":{},"상":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"억":{"docs":{},"제":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}}}}}},"케":{"docs":{},"이":{"docs":{},"스":{"docs":{},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"헤":{"docs":{},"더":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"쉼":{"docs":{},"표":{"docs":{},"로":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"창":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}},"length":22138},"corpusTokens":["!","!==","!array.isarray(arguments[1]))","!를","\"","\"!node_modules/**/*.ts\"]","\"\"","\"\",","\"\";","\"$$\",","\")","\");","\"*!text\"","\"*\"(모든","\"*\",","\"*\":","\"**/*.spec.ts\"","\"+\":","\",","\",\"","\".\",","\".\"보다","\"...\";에서","\"../../built/local/tsc.js\",","\"../constants/http\";","\"../node_modules/jquery/dist/jquery\"에","\"./app\";","\"./app.ts\"","\"./app.ts\",","\"./built\",","\"./calculator\";","\"./components/entry\";","\"./components/hello\";","\"./configs/base\",","\"./dist/\",","\"./dist/bundle.js\",","\"./greet\";","\"./lettersonlyvalidator\";","\"./lib/main.d.ts\"","\"./lib/main.d.ts\",","\"./lib/main.js\",","\"./main.ts\"","\"./map\";","\"./mi","\"./mod\";","\"./mod\"],","\"./model\"","\"./model.ts\",","\"./model.ts\"를","\"./moduleb\"를","\"./moduleb\"와","\"./myclass\";","\"./mycomponent\";","\"./myfunc\";","\"./mylargemodule.ts\";","\"./mythings\";","\"./observable\"","\"./observable\";","\"./onetwothree\";","\"./programmercalculator\";","\"./shapes\";","\"./src\"를","\"./src/**/*\"","\"./src/index.ts\",","\"./src/index.tsx\",","\"./staticzipcodevalidator\";","\"./stringvalidator\";","\"./template\"로","\"./tsconfig\",","\"./validation\";","\"./xyz.txt!text\";","\"./zipcodevalidator\";","\".\\n\\n\"","\".js\",","\".js\"]","\".json\"]","\".ts\",","\".tsx\",","\".web.js\",","\".webpack.js\",","\"/\":","\"/dist\"","\"/mod\";","\"/node_modules/typescript/lib\"","\"0\"","\"0\",","\"0.1.2\",","\"0.19.24\",","\"001+010=\");","\"1\",","\"1+2*33/11=\");","\"1.0.0","\"1.0.0\",","\"100\"","\"101\"];","\"10억","\"123\"","\"123\";","\"2\",","\"2.0.0","\"2.2.0\"","\"3\",","\"3.9.0\",","\"4\",","\"5\",","\"5.0.0","\"6\"","\"6\",","\"7\",","\"8\",","\"9\",","\"98052\",","\":","\";","\"=\")","\"@angular/core\";","\"@types\"","\"@types/browserify\":","\"^0.6.4\",","\"a","\"a\"","\"a\");","\"a\",","\"a\";","\"adams\");","\"adams\",","\"alice\",","\"alice\"});","\"allowjs\":","\"ambient\"으로","\"amd\"","\"amd\",","\"amd\"와","\"angl","\"angular2\":","\"angular2/core\"","\"angular2/platform/browser\";","\"aurora\",","\"author\":","\"awesom","\"awesome\",","\"b\",","\"bar\"","\"bar\",","\"bar\";","\"bar\"].map(funct","\"bar\"].map(i","\"baseurl\":","\"baseurl\"과","\"baseurl\"에","\"baz\")","\"baz\",","\"binder.ts\",","\"black\"","\"blue\";","\"bob","\"bob\";","\"bob\"];","\"boolean\",","\"browserifi","\"browserify\":","\"bundle.js\"","\"bundle.js\",","\"c\"","\"c\",","\"c\";","\"canvas\"):","\"cat\",","\"cat\";","\"checker.ts\",","\"circle\":","\"circle\";","\"classic\"","\"clubs\",","\"commandlineparser.ts\",","\"commonjs\"","\"commonjs\",","\"compileonsave\":","\"compileroptions\"","\"compileroptions\":","\"compileroptions\"에","\"core.ts\",","\"crlf\"","\"current","\"cyan\")","\"d\",","\"danielle\",","\"default\";","\"del\":","\"del\"을","\"dependencies\"","\"dependencies\":","\"dependencies\"에","\"devdependencies\",","\"devdependencies\":","\"diagnosticinformationmap.generated.ts\"","\"diamonds\",","\"diamonds\"],","\"diamonds\"];","\"div\"):","\"doe","\"dog\",","\"dom\"","\"dom\"]을","\"down\",","\"e\",","\"eas","\"emitdecoratormetadata\":","\"emitter.ts\",","\"es2015\"","\"es2015\",","\"es2016\",","\"es2017\"","\"es3\"","\"es5\"","\"es5\",","\"es6\"","\"es6\",","\"es6\"/\"es2015\",","\"es6\"와","\"esnext\".","\"esnext\".►","\"esnext\"는","\"exclude\"","\"exclude\":","\"exclude\"는","\"exclude\"에","\"excludes\"에","\"experimentaldecorators\":","\"exports\",","\"exports\"],","\"express\"]","\"extends\":","\"f\"];","\"files\"","\"files\":","\"files\"과","\"files\"에","\"foo\"","\"foo\",","\"foo\";","\"fred\"];","\"free\"];","\"fs\"","\"function\"","\"generated\"가","\"generated/*\"","\"generated/templates/views\"","\"greeter","\"greeter라는","\"greeting\");","\"gulp\":","\"gulp\"와","\"hamster\"","\"hamster\"]);","\"hearts\",","\"hello","\"hello!\";","\"hello\"];","\"hello,","\"hey","\"host","\"hot","\"hour\");","\"howdy\";","\"i'll","\"img\"):","\"include\"","\"include\":","\"include\"을","\"input\"):","\"jane","\"jane\",","\"jquery\":","\"jquery\";","\"jquery\"에","\"json!*\"","\"json!http://example.com/data.json\";","\"jsx\":","\"kitty\";","\"latest\",","\"left\",","\"legacy/modulea\"],","\"lf\"","\"lib\":","\"lib/mainmodule.js\"","\"loading...\"","\"lodash\",","\"lodash\";","\"lucas\",","\"m\");","\"m.\",","\"mackinzie\");","\"magenta\")","\"main\"","\"main\":","\"main\"의","\"main.ts\",","\"mallory\";","\"mammals\";","\"man","\"matches\"","\"math","\"microsoft.aspnet.iisplatformhandler\":","\"microsoft.aspnet.server.kestrel\":","\"microsoft.aspnet.staticfiles\":","\"module\"","\"module\":","\"modulea\"","\"modulea\"와","\"modulea의","\"moduleb\"","\"moduleb\"는","\"moduleb\"를","\"moduleb\"와","\"modulename\";문을","\"moment\";","\"more","\"mystring\"","\"name\":","\"new","\"next","\"next\"","\"node\"","\"node_modules\",","\"node_modules/jquery/dist/jquery.slim.min.js\"로","\"noemitonerror\":","\"noimplicitany\"","\"noimplicitany\":","\"noisy\"","\"nomaplicitany\"가","\"none\",","\"number\")","\"number\",","\"number\";","\"number\"를","\"object\"","\"object\")","\"oh","\"outdir\":","\"outfile\":","\"output.js\"","\"output.js\")","\"override\";","\"padding\"을","\"parser.ts\",","\"pass","\"path\"","\"paths\"","\"paths\":","\"paths\"가","\"paths\"는","\"paths\"를","\"pre\",","\"preserve\"","\"preserve\".","\"preserveconstenums\":","\"prevent","\"program.ts\",","\"property\";","\"react","\"react\"","\"react\",","\"react\":","\"react\";","\"react\"를","\"react\"에","\"react\"와","\"react.createelement\"","\"reactdom\"","\"rectangle\":","\"rectangle\";","\"red\",","\"red\";","\"reflect","\"removecomments\":","\"rich\"","\"rich\",","\"rich\"를","\"right\",","\"rootdirs\":","\"rootdirs\"를","\"rory\";","\"rxjs\":","\"sales\");","\"samuel\",","\"scanner.ts\",","\"seattle\"","\"seattle\";","\"seattle\"});","\"secret","\"size","\"smith\")","\"smith\"로","\"somemodule\"","\"somemodule\";","\"sourc","\"sourcemap\":","\"spades\",","\"span\"):","\"species\"","\"spicy\",","\"square\":","\"square\";","\"sr.\");","\"src/#{locale}\"","\"src/**/*\"","\"src/de\",","\"src/greet.ts\"","\"src/main.ts\"","\"src/main.ts\",","\"src/views\",","\"src/zh\",","\"strict","\"strictnullchecks\":","\"string\")","\"string\",","\"string\";","\"supplemental.ts\"","\"symbol\".typescript에서","\"sys.ts\",","\"system\"","\"system\",","\"system\"만","\"systemjs\":","\"t","\"target\":","\"test\"));","\"the","\"thi","\"thing\";","\"this\"를","\"triangle\"을","\"tsc.ts\",","\"typename\",","\"typename\"와","\"typename\"은","\"typeroots\"","\"types\"","\"types\",","\"types\":","\"types.ts\",","\"typescript\");","\"typescript\":","\"typescript\";","\"typescript\"와","\"typescript.tsdk\":","\"typescript_tsdk\":","\"typings\"","\"umd\",","\"uneasy\");","\"uneasy\"가","\"up\",","\"url\"","\"url\";","\"use","\"user\"","\"user\");","\"utf8\"","\"utilities.ts\",","\"value\"","\"vandelay","\"version\":","\"white\")","\"white\",","\"will","\"will\",","\"world\";","\"yellow\")","\"yes\"","\"yes\",","\"zone.js\":","\"很高兴认识你\"","\"您好吗\",","\"가상\"","\"가장","\"결함\"을","\"구조적","\"나를","\"내부","\"내부(internal)","\"네임","\"네임스페이스\"로","\"네임스페이스\"입니다.\"외부","\"네임스페이스\"입니다.\"외부(external)","\"다른","\"대상","\"덕","\"리터럴","\"메인\"","\"모듈\"입니다","\"문자열일수도","\"발견\"","\"배포\"되는","\"사전(dictionary)\"","\"상황적","\"선언","\"숨겨진","\"싱글톤","\"옵션","\"인덱스\"를","\"인스턴스","\"존재\"합니다.이것은","\"좋아요\"","\"직렬화(serialize)\"하는","\"최상위","\"추가\"하지","\"타당\"한","\"프로젝트\"로","\"하세요\"와","\"하지","\"환경\"을","\"회피하는\"","#1232","#2577","#{locale}을","$","$(\"button.continue\").html(","$(()","$:","$;","${","${compiler}","${compiler}`);","${distanceinmeters}m.`);","${framework}!`;","${name}`;","${this.department}.`;","${this.name}","${validate(s)","$가","$나","%","%,","%s\")","%s\")이","&","&&","&,","'","'!=='","'!=='는","'\"eas","'\"uneasy\"'","'#ff00ff'","'${","'${char}'`);","'${padding}'.`);","'*'","'.","'.',","'...',import","'./#{locale}/messages'에서","'./foo';","'./lib/typescript.d.ts'","'./lib/typescript.d.ts'가","'./template1')","'./view2')","'./zh/messages'의","'.js'","'.ts'","'.ts'와","'.tsx'","'.tsx'를","'0'","'1'과","'10'","'100'","'11'","'2'","'a'","'a'가","'a'는","'a'를","'address'로","'age'","'age');","'age'에","'age'와","'animal'과","'any'","'arg'로","'awesom","'b'","'b';","'b'는","'boolean'은","'c'","'cats',","'cjs',","'clean'작업도","'clean'작업이","'clor'프로퍼티가","'colour'는","'const'를","'copi","'d'","'default'","'default'...","'default'로","'define'.","'e'는","'e.bar'","'e.foo'","'employee'는","'fly'","'folder1/file2'","'folder2/file3'","'folder2/file3')","'foo!'에","'foo'.과","'foo'가","'foo'는","'foo'에","'generated/*'","'green'을","'helloprops'는","'if'","'image'","'jarid',","'john","'js'","'lettersonlyvalidator'","'m'의","'modulea'가","'modulea'을","'moduleb'","'mycomponent'의","'name'","'name');","'name'은","'name'의","'name'이","'new","'new'","'node_modules'","'node_modules/angular2/bundles/angular2","'node_modules/rxjs/bundles/rx.js']","'node_modules/systemjs/dist/system.src.js',","'node_modules/typescript.d.ts'","'node_modules/typescript.ts'","'node_modules/typescript.tsx'","'node_modules/typescript/lib/typescript.d.ts'","'node_modules/typescript/lib/typescript.d.ts'.","'node_modules/typescript/lib/typescript.d.ts'를","'node_modules/typescript/lib/typescript.d.ts'에서","'node_modules/typescript/package.json'.","'nodejs'","'nodejs'.","'null'은","'null'일","'number","'number'에","'number'은","'number[]'","'object'","'option1'","'option2';","'package.json'","'package.json'에는","'padding'이","'person'","'person'의","'red';","'require'","'require'.와","'scripts':","'scripts/**/*.map'],","'scripts/**/*.ts',","'some","'somelib';","'sourc","'squareconfig'","'src/app.ts'.","'src/node_modules/typescript.d.ts'","'src/node_modules/typescript.ts'","'src/node_modules/typescript.tsx'","'src/node_modules/typescript/package.json'","'state'","'string","'string'","'string'.","'string'에","'string'은","'string[]'타입이","'stringvalidator'","'substr'을","'swim'과","'t","'target'과","'target'으로","'this'를","'tofixed'","'tostring'이","'tsconfig.json'의","'types'","'typescript'","'typescript'는","'undefined'","'undefined'는","'undefined'를","'unknown');","'unknown']);","'unknown'은","'value'로","'x'","'x'를","'x'와","'x'의","'y'에는","'zipcodevalidator'","'{bar?:","'{foo?:","'{}'타입을","'네임스페이스","'버려지는'","'선언","'안에","'위로'","'호환성'을","(","(!(valu","(!result.hasownproperty(id))","(!somebody)","(\"main\"","(\"ts.transpilemodule\"과","(\"types\"","(()","((pet).swim)","()","(...)","(...arg:","(...args:","(.net","(.ts,","(.ts,.d.t","(0.02","(0.05","(0.13","(1)과","(15)에서","(2)는","(4)와","(7)에서","(8)과","(@configurable)의","(@enumerable)의","(@required)의","(`","(a","(a:","(abstract","(accessor","(accessors)","(ad","(add","(addit","(advanc","(age","(aliases)","(allowj","(also","(ambient","(amd),","(any,","(arg:","(arguments.length","(array","(array)","(attribut","(b)","(b:","(base","(basevalue:","(basic","(basics)","(becaus","(best","(block","(boolean)","(build","(char","(children","(class","(classes)","(classic)","(code","(colornam","(common","(commonj","(commonjs),","(compar","(compil","(compileroptions,files,includ","(comput","(condition)","(config.color)","(config.width)","(configur","(const","(constructor","(contextu","(creat","(ctrl","(data:","(debug)","(decor","(default","(destructuring)","(digit","(disallow","(discrimin","(do","(document.getelementbyid(\"compiler\")","(document.getelementbyid(\"framework\")","(done:","(dynam","(e)","(e).y));","(e:","(earli","(eas","(either","(element:","(embed","(employee.fullname)","(enum","(enum)","(enums)","(err)","(err,","(es6)에","(excerpt)","(excess","(exhaust","(explicitli","(export","(export)","(extend","(f","(f)","(factory)","(first","(first)[id];","(firstname:","(fname:","(foo","(foo를","(function","(functions)","(gener","(generics)","(get","(global","(guidanc","(hello","(here","(heterogen","(hour:","(how","(hybrid","(i)","(i.e.","(if","(implement","(import","(in","(includ","(index","(infer","(inheritance)","(initi","(input)","(instal","(instanceof","(integr","(interfac","(interfaces)","(intersect","(intrins","(introduction)","(isfish(pet))","(isnumber(padding))","(isstring(padding))","(it","(iterables)","(javascript)","(lastname)","(lay","(let","(mac)","(merg","(method","(microsoft.typescript.targets,","(minim","(mod_1_1)","(modul","(move","(n:","(name","(needless","(needzipvalidation)","(never","(next","(no","(node)","(node.j","(node.js),","(number)","(number)로","(number를","(numer","(object","(of","(opt","(option","(or","(our","(outdir와","(overloads)","(paramet","(parameterindex","(passcod","(path","(pet).fly();","(pet).swim","(pet).swim();","(pet.fly)","(pet.swim)","(pitfal","(point.i","(point.x","(polymorph","(preprocess","(privat","(programmercalculator.digits.indexof(digit)","(prop:","(properti","(props)","(props:","(public","(public,","(put","(re","(react","(react.createelement(\"div\"))로","(react.createelement(mycomponent))가","(readonli","(red","(rel","(require,","(requiredparameters)","(require를","(rest","(result)[id]","(revers","(rhino","(root,","(run","(runtim","(s.kind)","(s:","(scope","(second)[id];","(see","(selector:","(sequenti","(set","(sfc)","(shouldinitialize)","(simpl","(simplifi","(sn","(somevalu","(somevalue).length;","(source:","(split","(spread)","(start","(start:","(statements)","(static","(strict","(string","(string)","(string)으로","(subtyp","(target","(target)","(target,","(target:","(test","(test)","(the","(thename:","(thi","(thing","(this.greeting)","(this.operator)","(this:","(through","(too","(trace","(trade","(true)","(tsc.exe,","(tuple)","(type","(typeof","(understand","(union","(unix","(unspecifi","(updat","(us):","(use","(user","(v","(valid","(validator.isacceptable(\"...\"))","(valu","(value:","(var","(variabl","(virtual","(weed","(well","(when","(whi","(work","(write","(x","(x)","(x,","(x.isacceptable(\"...\"))","(x86)\\msbuild\\microsoft\\visualstudio\\v$(visualstudioversion)\\typescript\\microsoft.typescript.target","(x:","(x?,","(x와","(y","(y:","(zipcodevalidator:","({","({name:","(공통","(그러나","(그리고","(글로벌","(기본값),","(기본적으로","(꺾쇠괄호)","(다른","(디렉토리","(또는","(맨","(모듈","(모듈로","(병합되지","(예","(예.","(예:","(윈도우)","(유닉스).\"","(이","(이것들이","(인코딩","(주어진","(즉","(즉,","(최소","(타입","(특정",")","):",");","*","**","**/","*,","*/","*/,","*/];","*=","*code*","*declaration*","*만","*속성)가","+","+,","+=",",",".","..","...","....","...;","...c","...default","...defaults,","...first,","...nums:","...passthrough","...rest:","...rest]","...restofname:","...second,","../","../../node_modules/@types/","../node_modules/@types/,","./","./#{locale}/messages를","./#{locale}/messages와","./de/messag","./dist/main.js를","./node_modules/@types/,","./node_modules/@types/express만","./node_modules/@types/lodash","./node_modules/@types/node,","./node_modules/@types의","./typings의","./zh/messages,","./zh/messages에는",".add(\"main.ts\")",".add(1)",".alert(...)",".bundle()",".currentvalue();",".d.t",".d.ts)을",".entry(\"entry.ts\")",".es,",".es6",".h파일로",".j",".js,",".js.pipe(gulp.dest(\"dist\"));",".json",".jsx",".jsx).",".jsx)도",".js로",".js와",".js파일에는",".length",".log(...)",".map",".multiply(5)",".pipe(buffer())",".pipe(gulp.dest(\"dist\"));",".pipe(gulp.dest('dist'));",".pipe(process.stdout);",".pipe(source('bundle.js'))",".pipe(sourcemaps.init({loadmaps:",".pipe(sourcemaps.write('./'))",".pipe(ts({",".pipe(tsproject())",".pipe(uglify())",".plugin(\"tsify\",",".plugin(tsify)",".run(funct",".sin()",".t",".transform('babelify',",".ts,",".ts/.tsx",".tsx",".tsx)",".tsx,",".tsx로",".ts로",".ts와",".use(typescript())",".vscode/settings.json","/","/*","/*!로","/**","/,","//","///","////////////////////////////////////////","//그래도","/\\.js$/,","/\\.tsx?$/,","/^[0","/^[a","/collections/generic/","/generated/templates/views에","/generated/을","/moduleb.d.t","/moduleb.t","/node_modules/moduleb.d.t","/node_modules/moduleb.j","/node_modules/moduleb.t","/node_modules/moduleb.tsx","/node_modules/moduleb/index.d.t","/node_modules/moduleb/index.j","/node_modules/moduleb/index.t","/node_modules/moduleb/index.tsx","/node_modules/moduleb/package.json","/node_modules/typescript/lib","/root/moduleb.d.t","/root/moduleb.t","/root/node_modules/moduleb.d.t","/root/node_modules/moduleb.j","/root/node_modules/moduleb.t","/root/node_modules/moduleb.tsx","/root/node_modules/moduleb/index.d.t","/root/node_modules/moduleb/index.j","/root/node_modules/moduleb/index.t","/root/node_modules/moduleb/index.tsx","/root/node_modules/moduleb/package.json","/root/src/folder/a.ts에","/root/src/folder/moduleb.d.t","/root/src/folder/moduleb.t","/root/src/modulea.js가","/root/src/modulea.js에","/root/src/modulea.ts에서","/root/src/moduleb","/root/src/moduleb.d.t","/root/src/moduleb.js라는","/root/src/moduleb.t","/root/src/moduleb.tsx","/root/src/moduleb/index.d.t","/root/src/moduleb/index.t","/root/src/moduleb/index.tsx","/root/src/moduleb/lib/mainmodule.js를","/root/src/moduleb/package.json","/root/src/node_modules/moduleb.d.t","/root/src/node_modules/moduleb.j","/root/src/node_modules/moduleb.t","/root/src/node_modules/moduleb.tsx","/root/src/node_modules/moduleb/index.d.t","/root/src/node_modules/moduleb/index.j","/root/src/node_modules/moduleb/index.t","/root/src/node_modules/moduleb/index.tsx","/root/src/node_modules/moduleb/package.json","/src/view","/undefined라고","/usr/local/lib/node_modules/typescript/lib","/을","0","0)","0);","0,","0.16beta","0.5","0;","0]","0b1010;","0o744;","0xf00d;","0});","0};","0개","0부터","0입니다.","1","1)","1).join(\"","1);","1,","1.1","1.1.2:","1.36","1.5에","1.5에서는","1.7","1.7).이렇게","1.8","1.8.4","10","10,","100","100)","100,","1000);","1000}","1001","100;","101","10;","10];","10am.\");","10}));","10};","10을","10이","10입니다.","10진수","11","11;","12","12,","123;","12;","13","13);","13;","13};","14","16","16진수와","17);","1;","1x","1로","1을","1이어야","2","2)","2));","2);","2,","2.0","2.0,","2.2).","2.3","20","20,","2013","2013:","2015","2015:","2015년을","2015부터","2015에서","2015와","2015의","2017","2017이","20;","2261","26","2808","2824","2;","2]);","2],","2];","2})}","2};","2를","2와","2의","2진수","3","3);","3,","32);","32)에","34m.","35","37;","3;","3];","3});","3};","3개의","3에는","4","4);","4,","4000","45)","4;","4]);","4];","4}","5","5)","5,","5.0;","500);","52);","5;","5];","5]값을","5m.","5x","5분","6","6,","6;","6];","6의","7","7,","8","8;","8진수","9","9;","9]+$/;",":",":)",":data",";","<>","=","==","===","========","=>","=를",">",">=",">>,",">>>,","?","?로","?를","@augment","@classdecor","@component({","@configur","@configurable(false)","@enumer","@enumerable(false)","@f","@f()","@format","@format(\"hello,","@g","@g()","@intern","@param","@reflect.metadata","@reflect.metadata(\"design:type\",","@requir","@required와","@seal","@sealed가","@sealed을","@t","@type","@types,","@types/","@types/,","@types/browserifi","@types/lodash","@types/node/index.d.ts에","@types/react","@type{array.}","@type{array}","@valid","@표현식의","[","[\"\",","[\"**/*.ts\",","[\"./typings\"]","[\".ts\",","[\"0\",","[\"alice\",","[\"bob\",","[\"copi","[\"es2015\",","[\"hearts\",","[\"hello\",","[\"node\",","[\"node_modules/jquery/dist/jquery\"]","[\"require\",","[\"ts\"]);","['.ts']","['age',","['copyhtml'],","['es2015'],","['lib'],","['name']);","['node_modules/angular2/bundles/angular2.js',","['scripts/**/*.js',","['somelib'],","['src/*.html']","['src/main.ts'],","[,","[0","[0,","[1,","[10,","[10:34:20]","[10:34:21]","[10:35:22]","[10:35:24]","[1]","[2]","[3,","[4,","[]","[];","[]를","[directions.up,","[disposable,","[elemname:","[first,","[first]","[getclassnamesymbol](){","[index:","[k","[key:","[new","[number,","[p","[pickedsuit]의","[propname:","[s:","[second,","[somebody]","[string,","[sym]:","[x:","[x:string]:","[{","]","],","];","^","_","_.","_.padstart(\"hello","__dirnam","__extends,","__extends와","__rest,","__spread에","_fullname:","_i","_p0:","_p1:","_x:","_y:","_와","```","```t","`bob","`e`","`hello","`hello,","`mi","`types\"","`x`","a):","a++;","a,","a.a","a.b","a.b.c,","a.ts가","a.ts에","a.y);","a:","a:\"\"","a;","a;,","a[10]","abov","abstract","abstract으로","accept","access","accessor,","accid","accomplish","account","accountingdepart","accountingdepartment();","acquiring,","activ","activat","activatable]);","activate()","activate:","actual","ad","adams\"를","add","add(operand:","add(x,","add(x:","add:","addclicklistener(onclick:","addclicklistener가","addclicklistener에","addit","address:","addtoz(x,","advanc","advis","ag","again,","age:","age?:","agemap[\"daniel\"]처럼","agnostic,","album","album.albumlabel;","albumlabel","alert","alert(\"card:","alert(\"hello,","alert(\"thi","alert('hello","alert(buildlabel(\"sam","alert(colorname);","alert(stringnumeric.add(stringnumeric.zerovalue,","alert.","alertopt","alia","alias","alias):","alias;","aliased(arg:","aliased는","aliases)","aliases)은","aliases는","aliases도","aliases를","aliases와","aliases은","aliases을","aliasing(typ","alias가","alias를","alias에","allow","allowed.","allowj","allowjs에만","allowjs와","allowsyntheticdefaultimport","allowunreachablecod","allowunreachablecode와","allowunusedlabel","allowunusedlabels로","allvalidators.t","along","alreadi","alter","alway","alwaysstrict","alwaysstrict,","ambiance:","ambient","amd","amd,","amdmodule.j","amdmodule.t","amd를","amd모듈은","analog","analogclock","analogclock이","angular","angular가","anim","animal(\"cat\").name;","animal(\"goat\");","animal):","animal,","animal;","animal[]","animalshavemuscl","animalshavemuscles()","animals의","animal과","animal로","animal로부터","animal에","animal에서","animal을","animal의","animate(dx:","annotated되어","annotate를","annotations)","anoth","anothercomponent(prop:","any)","any):","any)=>ani","any)가","any,","any;","any[]","any[])","any[]):","any[],","anywher","any가","any는","any로","any를","any만","any에서와","any와","any을","any의","any입니다.","any입니다:","apart","api","api,","api를","api에","api의","app","app)","app.t","app.ts를","app.ts에","app.ts의","app.usedefaultfiles();","app.useiisplatformhandler();","app.usestaticfiles();","app`,","appear","appli","applic","applymixins(derivedctor:","applymixins(smartobject,","approach","approch.","appropri","approxim","area(s:","area:","area도","arg","arg;","argument","argument.\");","arguments)","arguments);","arguments.","arguments.length","arguments[0];","arguments[1];","arguments[parameterindex]","arguments를","arguments의","arg에","arg의","arity:","arr","arr:","array","array#foreach는","array(52),","array(pad","array(this.numspac","array)","array):","array.","array.prototyp","array.prototype.concat에","array.prototype.toobserv","array:","array;","array는","array와","array의","arrow","as.위","asp.net","aspect","assert","assertion)을","assertions)","assertions),","assertions)을","assertions은","assertion은","assertnever(s);","assertnever(x:","assertnever는","assign","assignment)","assumpt","astut","atom","auditing\");","augmentation)","author","automat","avail","awar","awesom","a{를","a를","a에","a와","a의","b","b);","b){","b,","b.ts가","b.ts는","b:","b;","b?:","babel","babel)에서","babel,","babelifi","babelify는","babelify도","babelify를","babelify에","babel과","babel은","babel의","back","badprop","bags)\"과","bags)\"을","bags)과","bar","bar(1);","bar(1,","bar(a,","bar,","bar.a;","bar:","bar;","bar?:","bark()","bark()와","bar의","base","base:","basector.prototype[name];","basectors.foreach(basector","basectors:","basedir:","baseurl","baseurl에","baseurl을","basic","basiccalcul","basiccalculator(2)","basiccalculator를","be","becom","bee","beekeep","beekeeper;","beep\");","befor","beforeall(action:","behav","behavior.","behavior:","below).","bend","benefits)","beta.11\",","beta.2\",","between","binary:","bird","bird):","bird가","bird는","bivari","bivariance)","block","blue","blue,","blue}","bobbington`;","body가","bookkeep","boolean","boolean)","boolean):","boolean,","boolean.","boolean;","booleanlikeheterogeneousenum","boolean}'입니다.","boolean은","boolean을","boolean이므로","bootstrap(myapp);","both","bothplu","bothplus에","bower_components,","box","box:","br","bracket\"","break","breakpoint가","breakpoint를","break문을","breed:","briefli","broadli","broken(name:","browse.","browser","browser\"","browserifi","browserify()","browserify({","browserify,","browserify가","browserify를","browserify에","browserify와","browserify의","buffer","buffer');","buffer와","bug","build","build)","buildlabel","buildlabel(name:","buildlabel.prefix","buildlabel.suffix;","buildname(\"bob\");","buildname(\"bob\",","buildname(\"joseph\",","buildname(firstnam","buildname(firstname:","buildname(undefined,","buildname;","buildnamefun:","build에는","built","builtd에","bundl","bundle()","bundle);","bundle);을","bundle.j","bundle.js가","bundle.js의","bundle을","button","button.animate(0,","byte","b가","b는","b를","b에는","b의","c","c#","c#에서는","c#의","c()","c();","c(10);","c):","c.a","c.b","c.d;","c.interv","c.prop","c.reset();","c.x;","c:","c:\\program","c;","c[getclassnamesymbol]();","cache:","calcul","calculatedistancefromorigin(point:","calculator();","calculator(2);","calculator,","calculator.t","call","callabl","callable.","callable/construct","callback","callback:","callbacks)","called\");","called.","calls)","calls.","captur","capture라고","card","card:","card;","cardpick","cardpicker();","cardpicker()는","cards:","card를","card와","care","caroline\",","case","case가","cat","cat):","cat;","catch","catskittyset","cd","cdn","cdn을","chang","charset","check","checking\"","checking)","checkj","checkjs를","checks)","children:","chinese:","choos","circl","circle,","circle;","citi","city;","city를","class","class)","class,","class.","class.d.t","class:","classdecorator(constructor:t)","classes)","classes,","classes:","classic","classnam","clause):","cli","clickableprop","cli를","clock","clockconstructor","clockconstructor,","clockconstructor와","clockinterfac","clockinterface;","clockinterface라는","clone","clone(animal:","clone.m();","clone.p;","cloner","close","cloud\"","cn","co","code","code\"]","code)","code,","code.","code:","code나","collaps","color","color(value:","color.blue;","color.green","color.green;","color.r","color:","color?:","color[2];","colorname:","color가","color에","colour","colour:","combin","combinations:","come","comfort","command","common","commonj","commonjs,","commonjs/node.j","commonjs/require.js)작은","commonjs가","commonjs를","commonjs모듈","commonjs와","compat","compil","compileonsav","compileonsave를","compiler)","compiler:","compiler?)","complex","complexity.","compon","component)","componentfoo(prop:","components/","components를","comput","concept","concepts)","config.clor;","config.color;","config.width","config.width;","configs/base.json:","configur","configurable(value:","configurationfile을","configure(iapplicationbuild","configure를","conflict","conflict.","conflicts\"","conflicts,","confusing,","consid","console.error.bind(console));","console.log(\"beep","console.log(\"depart","console.log(\"f():","console.log(\"g():","console.log(\"galloping...\");","console.log(\"gener","console.log(\"half","console.log(\"oh","console.log(\"roam","console.log(\"slithering...\");","console.log(\"th","console.log(\"tick","console.log(\"오류","console.log('clicked!');","console.log('hello!');","console.log('woof!","console.log((e).x","console.log(`\"${","console.log(`\"${s}\"","console.log(`${this.name}","console.log(`'${","console.log(`anim","console.log(`hello","console.log(a","console.log(a.x","console.log(arg.length);","console.log(data,","console.log(e));","console.log(e);","console.log(e.x","console.log(employee.fullname);","console.log(entry);","console.log(f());","console.log(first);","console.log(greeter.greet());","console.log(greeter1.greet());","console.log(greeter2.greet());","console.log(grid1.calculatedistancefromorigin({x:","console.log(grid2.calculatedistancefromorigin({x:","console.log(howard.getelevatorpitch());","console.log(howard.name);","console.log(i);","console.log(item));","console.log(labelledobj.label);","console.log(moment.format());","console.log(mouseevent.button);","console.log(new","console.log(num);","console.log(obj[sym]);","console.log(pet);","console.log(rest);","console.log(sayhello(\"typescript\"));","console.log(second);","console.log(this.isact","console.log(x","console.log(x)","console.log(x.count);","console.log(x.startswithhello());","console.log(x[0].substr(1));","console.log(x[1].substr(1));","console.log(x[5].tostring());","console.log(y.reverseandsort());","consolelogg","consolelogger());","const","const))","const,","const.","constant","constraints)","construct","constructable,","constructor","constructor()","constructor(greeting:","constructor(h:","constructor(m:","constructor(message:","constructor(name:","constructor(numfeet:","constructor(priv","constructor(protect","constructor(publ","constructor(readonli","constructor(thename:","constructor(valu","constructor(x:","constructor.","const는","const를","const변수의","consum","consumed.","consumer.t","consumpt","contain","content:","content;","context","context:","contribut","control","control과","control을","control의","conveni","convers","copi","core","core)","core를","correctli","correspond","count","count:","counter","counter.interv","counter.reset","counter;","cover","creat","create(c:","createcardpicker(this:","createcardpicker:","createcardpicker는","createclock","createclock(","createclock(analogclock,","createclock(digitalclock,","createclock의","createelement(tagname:","createelement와","creategreeting(s)","createinstance(bee).keeper.hasmask;","createinstance(c:","createinstance(lion).keeper.nametag;","createsquare(config:","createsquare(squareoptions);","createsquare({","createsquare를","createsquare에서","createsquare의","createzoo():","crlf","cs","ctor(hour,","ctor:","current","currenttime:","currentvalu","currentvalue():","currentvalue:","custom","customcomp","czech:","c를","d","d.t","d3","d3.base;","d3.d.t","d3:","d3는","d3이라는","d:","d;","dad","dad.nam","danger","data","data:","date)","date);","date;","de","deactivate()","deactivate:","dead","debug","debug:","debugg","decimal:","deck","deck)","deck):","deck.createcardpicker();","deck:","deck객체를","deck를","deck에","declar","declaration)","declaration.","declaration:","declarationdir","declarations!","declarations)","declarations,","declarations.","declarations.d.t","declarations으로","declaration에","declaration을","decorator,","decorators)","decorator가","decorator는","deep","default","default)","default:","defaultextension:","defaulthead","defaults의","default를","default의","defin","define(\"namedmodule\",","define(...)","define(...,","define(...args:","define([\"foo\"],","define([\"libname\"],","define([\"require\",","define,","define.amd)","defines.","define을","definit","definitelytyp","del","del(['wwwroot/scripts/**/*']);","demonstr","depart","department();","department.generatereports();","department.printmeeting();","department.printname();","department:","department;","depend","dependencies)","dependencies에","dependency에","deprec","derivedctor.prototype[name]","describ","descriptor","descriptor.configur","descriptor.enumer","descriptor.set","descriptor.set;","descriptor.valu","descriptor.value;","descriptor:","descriptor가","descriptor는","descriptor로","descriptor에","descriptor의","design","destructur","destructuring)","detail","details.","detect","dev","devdepend","devdependencies.","develop","devtool:","diagnost","dictionari","dictionary)","didn't","diff(one:","differ","differ.","differences)가","differenti","digit","digitalclock","direct","direction.up","directions.down,","directions.left,","directions.right]","directive:","directori","directories)","disablesizelimit","discourag","discrimin","discriminant.","display","dispos","disposable,","disposable과","dispose()","dispose:","disregard","dist","dist/","dist/bundle.j","dist/index.html을","dist/main.j","distancefromorigin(point:","distinct","distinguish","dist에서","dist의","div","dive","div가","do'","doanimalshavemuscles()","document","document.body.innerhtml","document.getelementbyid(\"example\")","document.getelementbyid(divname);","documentation.","documentation:","document의","doe';","doesn't","dog","dog();","dog):","dog.bark();","dog.move(10);","dog;","dog는","dog의","dom","dom\":","dom\";","dom\"과","dom,es5,scripthost","dom,es6,dom.iterable,scripthost","dom.iter","dom을","dom의","don't","done","donefn)","dot","down","down,","downleveliter","download","drop을","due","duo","duo(__dirname)","duration:","duration?:","dx","dy","dy:","e","e)","e.bar","e.bar)","e.foo","e.g.","e.messag","e.message;","e.x","e.y)));","e.y));","e1","e2","e2의","e:","each","earlier","earth...\");","eas","easi","easier","easing)","easing:","echo","ecmascipt","ecmascript","ecmascript2015","ecmascript2015에","ecmascript3","ecmascript5","ed","edge에서","effect","effects.","either.","elapsedtim","elapsedtime:","elapsedtime?:","element","element;","elementattributesproperti","elementchildrenattribut","elementclass","elements)","eleph","elephant(),","elephant,","elsewher","elt","elt.innertext","emitbom","emitdecoratormetadata","emitdecoratormetadata[1]","emitdecoratormetadata을","emit을","employe","employee(\"bob\");","employee(\"howard\",","employee();","employee.fullnam","employee;","employeenam","employee는","employee라는","employee를","employee에게","employee의","empti","empty;","empty를","empty에","en","end","ended)","enforc","enforce:","english","enough,","ensur","entir","entri","entries:","entry.t","entry:","entry를","enum","enum.a;","enum;","enum[a];","enum[enum[\"a\"]","enumer","enumerable(value:","enums)","enums는","enum에서","enum은","enum의","environ","environment.","epithet;","err;","error","error(\"bas","error(\"miss","error(\"someth","error(\"unexpect","error(`expect","error(`unsupport","error(message);","error(message:","error,","errors)","es","es2015","es2015,","es2015.collect","es2015.cor","es2015.gener","es2015.iter","es2015.promis","es2015.proxi","es2015.reflect","es2015.symbol","es2015.symbol.wellknown","es2015/es6는","es2015도","es2015를","es2015에","es2015에서","es2015인","es2016","es2016.array.includ","es2017","es2017.object","es2017.sharedmemori","es2017.typedarray","es3)","es3,","es3를","es3와","es3으로","es5","es5,","es5:","es5를","es5보다","es6","es6),","es6,","es6:","es6의","es7","esnext","esnext.asynciter","esnext.promis","especi","evalu","evaluate()","evaluated\");","evaluateoperator(operator:","evaluation)","event","event)","event:","event;","eventtarget):","eventtyp","eventtype,","exact","exactli","exampl","example)","example,","example:","example;","excerpt)","excess","exclud","exclude는","exclude와","execute:","exist","exist.","existingrequiredparameters,","existingrequiredparameters.push(parameterindex);","existingrequiredparameters:","exp","exp();","exp)","expect","expected,","experimentalasyncfunct","experimentaldecor","experimentaldecorators[1]","explain","explicit","explicit,","explorer가","explorer를","export","export)는","export.","exported)","exported되지","exports)","exports);","exports,","exports.c","exports.t","exports_1(\"t\",","exports가","exports는","exports는이","exports도","exports로","exports를","exports에","export가","export된","export로","export를","export만","export의","export인","export하는","expos","express","express();","express,","expression...\"","expressions)","expressions.","expr은","expr입니다.따라서","extend","extend(first:","extend(new","extend)","extends)","extends는","extends를","extends에서","extends의","extend에","extens","extension\",","extensions:","extensions을","extern","externals:","extran","extrem","f","f()","f():","f();","f(1);","f(1,","f([1,","f([first,","f(condition,","f(e);","f(false);","f(false,","f(g(x))와","f(input:","f(obj:","f(shouldinitialize:","f(sn:","f(this:","f(true);","f(true,","f(x)","f(x:","f({","f({});","f12","f5키를","factory(require(\"libname\"));","factory(require,","factory(root.libname);","factory)","factory);","factory는","fail()","failed\");","fall","fallthrough","fals","false)함수","false,","false;","false];","family,","faq","far.","faster.","favored.","favorit","featur","feedpets(pets)","feet:","fetcher","few","fewer","field","file","file)","file,","file.","file1.j","file1.t","file2.j","file2.t","file3.t","fileaccess","filecont","filecontent);","filename:","files)","files,","files.","files].","file을","final\"","final\",","finally,","find","fine","finish","first","first)","first,","first];","firstnam","firstname:","firstname;","firstname에","first와","fish","fish가","fish는","fish라는","fish의","fixed(name:","flag","flags)","fli","flower","fly();","fly라는","fn():","fn(myelem);","fn(x.diff);","fn(x:","focus","folder.","folder1","folder1/file2","folder2","folder2/file3","follow","following:","foo","foo!.length;","foo()","foo();","foo(x:","foo,","foo.d.ts:","foo.dostuff();","foo.length;","foo.sometyp","foo.somevar.a;","foo:","foo;","foo?:","food","food:","fooprop","fooprop)","footnot","footnote.","foo라고","for)","for,","for..in","for..in은","for..of","for..of,","for..of는","for..of와","forceconsistentcasinginfilenam","form","format(formatstring:","format:","formatmetadatakey","formatstr","formatstring);","formatstring.replace(\"%s\",","for루프에","found","fourth]","fr","framework","framework:","frankwallis/duo","french:","friendli","fs","fs.readfilesync(f);","fs.writefilesync(out,","fulli","fullnam","fullname():","fullname(newname:","fullname:","fullname에","fullname을","function","function()","function(exports_1)","function(f)","function(foo)","function(grunt)","function(mouseevent)","function(mouseevent:","function(pets)","function(point:","function(s)","function(somelib)","function(source:","function(src,","function(src:","function(start:","function(this:","function(x,","function(x:","function(y:","function)","function).","function,","function.","function.d.t","function.d.ts.","function:","functions)","functions,","functions.","function가","function만","fuss.","f와","f의","f함수","f함수가","f함수에서","g","g()","g():","g();","g)(x)은(는)","g.alert({","g.log({","galloping...","gener","general\"","general,","generated/folder2/file3","generatereports():","genericidentityfn","genericnumb","genericnumber();","generics)","german:","get","get():","getciti","getcity();","getcity;","getclassnamesymbol","getcompiler()","getcounter():","getcounter();","getdistance(p:","getdistance의","getelevatorpitch()","getformat","getformat(target:","getformat(this,","getgreeting()","getname(n:","getobject(done:","getpaddingstring()","getpaddingstring():","getproperty(o:","getproperty(obj:","getproperty(person,","getproperty(x,","getproperty라는","getproperty에서,","getproperty의","getrandompadder()","getresult()","getsmallpet():","getsmallpet();","getsomevalue(),","getter","getters/setters를","getter와","getthing()","getthing():","getwidget","getwidget(\"al","getwidget(43);","getwidget(n:","getwidget(s:","get과","get을","give","given","glob","global","global.","global.d.t","go","good","green","green,","greet","greet(\"hello\");","greet(\"hello,","greet()","greet(@requir","greet(g:","greet(getgreeting);","greet(greeting:","greet(n:","greet(new","greet(setting:","greet(y);","greet({","greet.ts를","greet.ts에서","greeter","greeter(\"hello\");","greeter(\"hello,","greeter(\"world\"));","greeter(\"world\");","greeter();","greeter(message)","greeter(person","greeter(person)","greeter(person:","greeter(user);","greeter.html","greeter.j","greeter.prototype.greet","greeter.standardgreeting;","greeter.t","greeter.ts파일을","greeter1","greeter1:","greeter1은","greeter2:","greeter:","greeter;","greetermaker();","greetermaker.standardgreet","greetermaker:","greetermaker라는","greeter는","greeter라고","greeter를","greeter을","greeter의","greeter클래스의","greeting\"","greeting,","greeting:","greetinglib","greetinglib.opt","greetinglib.options.log","greetinglik","greetinglike):","greetings\");","greetings,","greetingset","greetingsettings):","grid","grid(1.0);","grid(5.0);","grid.origin.x);","grid.origin.y);","grid1","grid2","grid를","grid의","grunt","grunt.initconfig({","grunt.loadnpmtasks(\"grunt","grunt.registertask(\"default\",","gruntfile.j","guard","guard)는","guards)","guard라는","guid","guidanc","guide,","guidelin","guide를","gulp","gulp)","gulp,","gulp.src(\"src/*.ts\")","gulp.src(paths.libs).pipe(gulp.dest('wwwroot/scripts/lib'));","gulp.src(paths.pages)","gulp.src(paths.scripts).pipe(gulp.dest('wwwroot/scripts'))","gulp.src(paths.scripts).pipe(gulp.dest('wwwroot/scripts'));","gulp.task(\"copi","gulp.task(\"default\",","gulp.task('clean',","gulp.task('copyhtml',","gulp.task('default',","gulp.task('lib',","gulpfil","gulpfile.j","gulpfile.js)","gulpfile.js라는","gulpfile.js를","gulpfile.js은","gulpfile을","gulp로","gulp를","gulp에서","gulp을","gulp의","gutil","gutil.log);","gutil.log);을","g을","g함수가","g함수는","h","h.","hand,","handbook","handbook에서","handbook을","handbook의","handelchar(char:","handler","handler();","handler,","handler:","handler의","hard","hasmask:","have.","have:","havemuscl","havemuscles;","havemuscles가","height:","hello","hello(\"typescript\");","hello(compiler:","hello.tsx라는","hello.tsx에","hello:","helloprop","helloprops)","help","here","here,","here.","hex:","hidden","hierarchy,","high","higher)","hint","home:","homeprop","homeprops):","hors","horse(\"tommi","horse과","horse는","horse의","hostname?:","hour:","howard","however,","html","html\",","html\"],","html'","html'...","htmlcanvaselement;","htmldivelement):","htmldivelement;","htmlelement):","htmlelement;","htmlimageelement;","htmlinputelement).value;","htmlinputelement;","htmlspanelement;","html이","http://go.microsoft.com/fwlink/?linkid=518007","http://json.schemastore.org/tsconfig에서","https://aka.ms/typ","https://github.com/definitelytyped/definitelytyped.","i'll","id","idea","ident","identifi","identifier!는","identifier의","identity(\"mystring\");","identity(arg:","identity;","ide를","ide에","ifitexists가","if문","ignored:","ignore를","iife로","iife를","imag","imagin","immut","impact","implement","implements를","implements와","implicit","import","import(예:'...'에서","import),","import).","import/export의","imported.","importhelp","importing를","imports(별칭으로","imports)","imports는","imports로","imports를","imports에","imports에서","imports의","import가","import는","import된","import로","import를","import문에서","import에","import에서는","import의","import하거나","import합니다.","in\"","in\")","in\");","in)","includ","inclusive.\");","incorrectli","increas","increment:","indentedstr","independent.","index","index,","index.d.t","index.d.ts와","index.html","index.html에","index.html을","index.html의","index.html이라는","index.html파일을","index.j","index.js)","index.js는","index.js라는","index.tsx로","index.tsx를","index.ts가","indexer를","indic","industries\",","infer","inference)","inference)에","infin","infiniteloop():","info:","information.","ing","inherit","init","initi","inlinesourc","inlinesourcemap","input","input:","input;","input[0];","input[1];","instal","install을","instanc","instance.","instanceof","instanceof의","instanti","instead","instead.","int32array,","integration)","intellij","intend","interact()","interest","interfac","interface)","interface):","interface.","interface;","interfaced(arg:","interfaces)","interface를","interpret","interval:","intrinsicel","introduc","introduct","invoc","invok","invokelat","invokelater([1,","invokelater(args:","is.","is:\"","isacceptable(s:","isactive:","isdisposed:","isdone:","isfish(pet:","isfish가","ismatch","isn't","isnumber(x:","isolatedmodul","isprim","isprime(2);","isprime(x:","isstring(x:","it'","it.","it:","italian:","item","items.foreach((item,","items.foreach(item","item을","iter","iterable로","ivogabe/gulp","i가","i는","i를","i와","ja","japanese:","java","javascript","javascript,","javascript가","javascript는","javascript로","javascript를","javascript에","javascript에는","javascript에서","javascript에서와","javascript와","javascript의","javascript이므로","javascript입니다.","javascript파일을","java를","java와","jim","jim.log();","jim.name;","john","join(...paths:","jqueri","jquery,","jquery.d.t","jquery;","jquery는","jquery라는","jquery에","js","jsdoc","jsdoc)","jsdoc@augments를","jsdoc에서","jsdoc으로","jsdoc을","jsdoc의","json","jspm","jspm@beta","jspm_packag","jspm의","jsx","jsx.element","jsx.element;","jsx.element[]","jsx.elementattributesproperty에","jsx.elementchildrenattribute를","jsx.elementclass는","jsx.elementclass에","jsx.element에","jsx.element의","jsx.intrinsicel","jsx.intrinsicelements라는","jsx.intrinsicelements에서","jsxfactori","jsxfactory를","jsx는","jsx를","jsx에서","jsx와","jsx의","js를","js에서","k","k)","k):","k.dosomething();","k[]):","k]:","katz의","keep","keeper:","keepwholeobject","keepwholeobject(wholeobject:","key","key:","keyboard","keycode:","keyev","keyof","keyof를","keyof와","keys:","keys]:","keys는","keyword","kind","kind:","kitti","kitty.nam","kitty.numl","kittyset","know","known","ko","korean:","k는","label","label:","labelledvalu","labelledvalue)","labelledvalue은","label이라는","languag","larg","last","lastnam","lastname:","lastname;","lastname?:","later","layeggs();","lead","left","left,","left:","leg","legal","legs\");","length","length:","lengthwis","length는","let'","let,","lettersonlyvalid","lettersonlyvalidator();","lettersonlyvalidator.t","lettersregexp","lettersregexp.test(s);","lettersregexp와","let과","let에","let은","let을","let의","let이","level","level)","lf","lib","lib\";","lib.d.t","lib.d.ts)를","lib.d.ts,","lib.d.ts와","librari","libraries)","libraries,","library!","library'","library,","library.","libs:","lib가","lib에","line","link","linkedlist","linkedlist;","lion","list","list)","list:","list[1]","listemittedfil","listenevent(eventtype.mouse,","listenevent(eventtype:","listfil","lists.","liter","live","load","loader","loader\"","loader'로","loader'에","loader).","loader:","loaders,","loaders:","loader가","loader는","loader도","loader를","loader에","loader와","loading...","local","localhost","locat","location:","lodash","lodash,","lodash를","lodash와","log","log()","log():","log.t","loggabl","loggable은","loggingident","loggingidentity(3);","loggingidentity(arg:","loggingidentity({length:","logopt","long","look","loop","m","m()","m.someth","m:","m;","made","main","main.t","main.ts라는","main.ts를","mainbutton(prop:","mainvalid","major","make","makegreet","makegreeting(s:","makesound():","manag","mandatori","mani","manual","many/too","map","map\",","map(f:","map,","map.j","map.t","map;","map['foo'];","mapping)","mappings)","maproot","maps으로","map과","mark","master","match","match\"","match\"}`);","matches\"","math","math.floor(math.random()","math.floor(pickedcard","math.floor(x","math.pi","math.random()","math.sin(this.value);","math.sqrt(dx","math.sqrt(xdist","mathlib.isprime(2);","mathlib;","maximum","maxnodemodulejsdepth","mean","meaning:","meanings:","meant","meet","member","member)는","members)","members)에","memori","merg","merges)","messag","message\");","message:","message;","metadata","metadata\":","metadata\";","method","method()","method,","method.apply(this,","microsoft.aspnetcore.staticfil","microsoft.typescript.compiler:","microsoft.typescript.default.prop","microsoft.typescript.default.props,","microsoft.typescript.msbuild:","microsoft.typescript.msbuild를","microsoft.typescript.target","middleiniti","middleinitial:","midnight까지","milliseconds)","mind","minute);","minute:","mixcolor(colorname:","mixin","mixin을","mkdir","mod_1","mod_1)","mod_1.someth","mod_1;","mod_1_1;","modal:","mode)에서","model","model.ts라는","modifi","modifier)","modifiers)","modul","modular","module\";","module)","module).","module,","module.","module.d.t","module.d.ts,","module.export","module.exports)","module.exports.feedpet","module.exports.readfil","module.exports에","module.exports와","module.js\";","module:","modulea)","modulea.callstuff()","modulea.t","modulea:mytyp","modulea는","modulea를","moduleb.j","moduleb가","moduleb를","moduleresolut","moduleresolution를","modules)","modules,","modules.","module을","moment","moment().utcoffset(x);","moment.js,","moment;","monday","month.\";","month.`;","more","more.","mouse,","mouseev","mouseevent)","move","move()","move():","move(distanceinmet","move(distanceinmeters:","move를","mozilla","ms","msbuild","msbuild에","msbuild에서","msbuild에서의","ms측의","multi","multipl","multiply(operand:","multiply는","my.application.customer.addform과","my.application.order.addform","myadd","myadd:","myadd는","myapp","myarray","myarray:","myarray[0];","myarray[2]","myarray[2]를","myclass.t","mycompon","mycomponent();","mycomponent가","mycoolfunction()","mycoolfunction(f:","mycoolfunction(function(x)","mycoolfunction가","mycoolfunction에","mycoolfunction이","mydeck","mydeck[pickcard(mydeck)];","myelem:","myfactoryfunction()","myfactoryfunction();","myfunc.t","mygenericnumb","mygenericnumber.add","mygenericnumber.zerovalu","mygreet","mygreeter());","mygreeter.greet","mygreeter.showgreeting();","mygreeter;","myidentity:","mylargemodul","mylargemodule.dog();","mylargemodule.t","mylib","mylib.","mylib.makegreeting(\"hello,","mylib.numberofgreetings;","mymodel","mymodel();","mymodules.d.t","myobj","myothermodule.t","mysearch","mysearch:","mysquar","mystr:","mytestpage.html","mythings.t","myurl","myvalid","n","n();","n)","n.name);","n:","n;","name","name!.charat(0)","name)","name,","name.","name.charat(0)","name:","name;","name?:","named)","named;","namedmodule이라는","nameofa","nameorresolv","nameorresolver):","nameresolv","nameresolver;","names)","names.map(n","names:","namespac","namespace,","namespace.","namespaces)","namespaces).","namespaces,","namespaces.","namespacing)","namespacing은","nametag:","name과","name은","name을","name의","name이","name이라는","nan","nativ","native.이","necessarili","need","need,","needed.","nest","network의","never","never):","never는","never를","never에","never의","new","new:","newlin","newname1","newname1\"로","newname1,","newname1를","newname2","newname;","newproperti","newsquar","newsquare.area","newsquare.color","newsquare;","new를","next","next:","nightli","nightlies는","no!","no!\";","nocheck","node","node.d.t","node.j","node.js\"","node.js)","node.js/io.j","node.js가","node.js는","node.js를","node.js보다","node.js에서","node.js의","node/commonj","node/commonjs를","node_modul","node_modules,","node_modules/@typ","node_modules라는","node_modules를","node_modules에서","node가","node는","node로","noemit","noemithelp","noemitonerror","noerrortrunc","nofallthroughcasesinswitch","nofallthroughcasesinswitch는","noimplicitani","noimplicitany,","noimplicitany:","noimplicitany를","noimplicitreturn","noimplicitreturns는","noimplicitthi","noimplicitthis,","noimplicitthis는","noimplicitusestrict","nolib","nolib를","non","none,","noresolv","noresolve)","noresolve가","noresolve를","normalize(p:","nostrictgenericcheck","notation.","notavalidcompon","notavalidfactoryfunction()","note","note:","notempti","notempty;","noth","notic","notion","notokay","notsur","notsure.ifitexists();","notsure.tofixed();","notsure:","nounusedloc","nounusedparamet","now","npm","npm)","npm,","npm.","npm3에서","npm:","npm과","npm을","nuget","nuget과","nuget를","nuget에","null","null'에","null)","null):","null);","null;","null];","nullabl","nullableperson","nulls:","null과","null과는","null로","null은","null을","null이라는","null일","num","num:","number","number'","number'에","number(이)거나","number)","number):","number);","number)를","number,","number;","number;})","number[]","number[]):","number[];","number[][])","number])","number]:","number];","numberdictionari","numberofgreet","numberofgreetings:","numberoflegs:","numberregexp","numberregexp.test(s);","numberregexp는","numbers)","number|string)","number|string):","number|undefined에","number}","number}}","number로","number를","number에","number와","number의","number이거나","number인","number입니다.","numer","numeric과","numfeet:","numlegs:","numlives:","numlivesforcat","numlivesforcat,","nums:","numspaces:","o","o.a;","o.a와","o.b;","o.b에서","o.map(x","o:","o;","o[n]);","o[name]:","o[name];","o[name]은","obj","obj.b","obj.property가","obj.x;","obj[\"property\"]으로도","obj[key];","object","object\"","object,","object.","object.getownpropertynames(basector.prototype).foreach(nam","object.seal(constructor);","object.seal(constructor.prototype);","object:","object;","objects,","object가","object보다","object와","obj에","observ","observable.j","observable.prototype.map","observable.prototype.map에","observable.t","observable.ts는","observable;","occur","octal:","octopu","octopus(\"man","of,","off","offer","ok","old","on","onc","onclickbad(this:","onclickbad는","onclickgood","onclickgood(this:","onclickgood는","onclick이","one,","onetwothree.t","onload:","only\"]","only)","only,","oo","oops!","oo의","opacity:","open","oper","operand;","operator)","operator:","operator;","opportun","option","option1:","option2:","optional:","optionalprop?:","optionals,","options.color","options.volum","options;","options에","options의","order","organ","organization,","origin","originalprop","origin에","other.","otherwis","out","out\"","out\"'","out\")","out\";","out)","out:","outdir","outdir로","outfil","outfile과","outfile을","output","output:","overload","overload.","overloads)","overloads,","overloads:","overview","p","p)","p.i","p.x","p0()","p0(value:","p1()","p1(value:","p1.x","p1:","p:","p;","packag","package,","package.json","package.json.","package.json가","package.json에","package.json을","package.json의","package:","packagecache:","packages,","packages.","packages:","packages를","pad","padder","padding:","padleft","padleft(\"hello","padleft(value:","padleft의","page","page)","page.","pages:","palomino","palomino\");","paragraph","paramet","parameter,","parameter.","parameterindex","parameterindex:","parameternam","parametername은","parameters)","parameters)라고","parameters:","parse(urlstr:","parseint(s).tostring()","parseintbasedzipcodevalid","parseintbasedzipcodevalidator.t","parsequerystring?,","part,","partial","partial.name은","partial;","partialperson","partial과","partial는","partial처럼","particularli","pass","passcod","passcode\")","passcode\";","passcode가","passcode를","passthrough.b","passthrough.c.length;","path","path.join(__dirname,","path:","pathname?:","paths[2]","pattern","pattern.","patterns,","peer","penstrok","penwidth:","peopl","people.name;","people.next.name;","people.next.next.name;","people.next.next.next.name;","people:","perform","person","person(\"jim\"),","person(\"john\");","person();","person)","person.firstnam","person.lastname;","person.name이","person:","person;","person['name']은","person['name']타입을","person[p]","person]:","person]?:","personparti","personprops:","personreadonli","person에","person으로부터","person은","person을","person의","pet","pet.fly()","pet.fly();","pet.layeggs();","pet.swim();","pets)","pets[\"species\"]","pet의","pet이","pick","pickcard","pickcard(15);","pickcard(x):","pickcard(x:","pickedcard","pickedcard.card","pickedcard.suit);","pickedcard1","pickedcard1.card","pickedcard1.suit);","pickedcard2","pickedcard2.card","pickedcard2.suit);","pickedcard;","pickedsuit","pick과","pick은","piec","pl","plain","pleas","pluck(o,","pluck(o:","pluck(person,","pluck과","pluck으로","plugin","plugin.d.t","plugins,","point","point)","point):","point,","point.prototype.distancefromorigin","point3d","point3d:","point:","point;","point가","point를","point입니다.","policy,","polish:","polyfills.js',","polyfill을","polygon","polygons.square();","popular","portuguese(brazil):","position:","possibl","possible)","possible.","possible:","postfix(\"great\");","postfix(epithet:","powershel","pr","predicate)","prefer","preferreduilang","prefix","preloaders:","present","present,","present.","preserv","preserve,","preserveconstenum","preservesymlink","preserve와","preset","presets:","preset을","pretti","pretty[1]","prettysure.tofixed();","prettysure:","pretty를","prevent","price:","primit","principl","printlabel(labelledobj:","printlabel(myobj);","printlabel에","printmeeting():","printname():","privat","private)","private,","private멤버가","private와","private으로","private을","private의","private이다;","privileg","probabl","processdigit(digit:","produc","programmercalcul","programmercalculator.digits.indexof(digit);","programmercalculator.digits.length)","programmercalculator.t","programmercalculator.ts를","programmercalculator는","proj","proj$","proj/","project","project)","project.","project.json에서","projectroot","projectroot/folder1/file2.ts.","projectroot/folder2/file3.ts.","projectroot/generated/folder2/file3.ts.","proj라고","proj로","proj의","proj이라는","promise((resolve,","promise;","promise과","prop","prop'","properti","properties)","properties.","properties:","properties;","propertiesdecorator등에","property\";","property,","propertydescriptor)","propertykey)","propertykey);","propertykey:","propertyname);","propertyname:","props.children","props:","props;","propstyp","props와","props의","protect","protected)","protected로","protected멤버가","protected멤버에도","protected입니다.","protocol?:","prototyp","provid","proxi","proxifi","proxify(o:","proxify(props);","proxify):","proxy;","proxyprop","pst","pt","public","public,","public를","public와","public으로","public을","public입니다.","publish","publishing,","pull","purpos","purpose:","put","python","python\");","qualiti","questions)","quick","quirks)","r.js)과","r.로","radius:","rais","rang","rare","rc1","react","react!","react!\"라고","react,","react.compon","react.component는","react.createel","react.createelement(\"div\")","react.createelement를","reactdom","reactdom.render(","reactnamespac","react를","react에서","react와","react의","read","reader","readfil","readonli","readonly,","readonly;","readonlyarray","readonlyarray를","readonlyarray타입이","readonlyperson","readonlystringarray","readonly도","readonly로","readonly를","readonly와","readonly을","readonly입니다.","ready,","real","realist","realli","reason","reason,","reasons.","recommend","record","record는","record와","rectangl","red","red,","refer","references)","reflect","reflect.definemetadata(requiredmetadatakey,","reflect.getmetadata(\"design:type\",","reflect.getmetadata(formatmetadatakey,","reflect.getownmetadata(requiredmetadatakey,","reflect.metadata","reflect.metadata(formatmetadatakey,","regexpbasedzipcodevalidator}","regist","reject()","reject)","rel","relat","relative로","removecom","renaming)","render()","render:","replac","reports...\");","represent.","request","request.","requir","require(\"...\");","require(\"...\")문이","require(\"./mod\");","require(\"./moduleb\");","require(\"./zipcodevalidator\");","require(\"bar\");","require(\"browserify\");","require(\"duo","require(\"duo\");","require(\"express\");","require(\"foo\");","require(\"fs\")","require(\"fs\");","require(\"gulp","require(\"gulp\");","require(\"mag","require(\"mod\");","require(\"module\")을","require(\"moduleb\");","require(\"moment\");","require(\"name\")를","require(\"path\")","require(\"tsify\");","require(\"url\");","require(\"watchify\");","require('browserify');","require('del');","require('gulp","require('gulp');","require('somelib');","require('tsify');","require('vinyl","require()","require([\"./zipcodevalidator\"],","require(modulename:","require(modulenames:","require(path:","require,","require.j","require.js)","require.js의","require.js입니다.","required(target:","requiredmetadatakey","requiredparameters)","requiredparameters:","requiredprop:","requiredprop이","requirej","requirejs,","requirejs/amd를","require라는","require에","reset():","resolut","resolution)","resolution은","resolv","resolve:","respond(\"princess","respond(recipient:","respons","response):","response.yes)","rest","restofname.join(\"","restor","result","result);","result.","result1","result2","result3","result4","result;","result[k]","results)","results.code);","return","return;","reusabl","revers","reverse(s:","reverse;","review","revisit","rhino","rhino(),","rhino();","rhino,","rhino;","rhino가","rhino는","right","right,","right:","right;","ro","ro.length","ro.push(5);","ro:","ro;","ro[0]","rolldie():","root","root.returnexport","rootdir","rootdirs)","rootdirs[2]","rootdirs를","rootdirs의","roots를","roughli","ru","rule","rules)","rules:","run","runner","runtim","runtime)","runtime)이","russian:","s","s.height","s.length","s.radiu","s.size","s.size;","s.width;","s:","s;","safe)","safer","safety)","sam","sam.move();","same","sammi","sampl","sample.j","save","sayhello","sayhello()","sayhello();","sayhello(name);","sayhello(name:","sayhello(somebody)","sayhello를","scale","scale:","scenarios)","scientificcalcul","scientificcalculator(2)","scientificcalculator는","scientificcalculator입니다.","scope","scoped.","scoping)","scoping이라고","script","script.","scripthost","scripts/app.ts를","scripts:","scripts라고","scripts를","scripts에","seal","sealed(constructor:","sealed(target)","search","searchfunc","searchfunc;","search의","second","second)","second,","second:","second]","second]:","seconds)","second라는","second의","section","section.","see","see:","seem","select","select()","select():","select:","selectablecontrol","selectablecontrol에는","selectablecontrol은","selectablecontrol을","selectablecontrol의","selection;","selector","selector:","sentence:","sep:","separ","serializ","serv","server)","set","set([\"cat\",","set(value);","set(value:","set,","setinterval(()","setters:[","setter가","setter에","settime(d:","settimeout","settimeout(()","settimeout은","settime과","set으로","set을","sever","sfc는","sfc로","shadow","shadowing)","shadowing은","shadows하기때문에","shape","shape)","shape):","shape,","shapeconsumer.t","shapekind","shapekind.circle;","shapekind.square,","shapekind.square;","shapes.polygons.square()'와","shapes.polygons;","shapes.shapes.triangle();","shapes.shapes?","shapes.t","shapes.triangle();","shapes은","shape에","sheep):","sheep;","shift","shim","shorter","shorthand","show","showgreeting():","showhello","showhello(\"greeting\",","showhello(divname:","showhello에","side","side:","sidelength:","sideprop","sideprops):","signatur","signature)","signature)을","signatures\"","signatures)","signatures)에","signatures)을","signatures)이","signatures)입니다.시그니처의","signatures:","signature로","significantli","similar","similarly.","simpl","simple.","simplemodule.j","simplemodule.t","simpli","simplifi","sin","sin()","singl","situat","size","size:","size;","skipdefaultlibcheck","skipdefaultlibcheck를","skiplibcheck","skiplibcheck를","slashesdenotehost?):","slithering...","small","smartobj","smartobj.interact(),","smartobject","smartobject();","smith\"));","smith\";","smith\"를","smrq/tsifi","sn","sn:","sn;","snake","snake(\"sammi","snake()];","snake)[]","snake와","snake을","so.","solut","somearray","somearray)","somebodi","somebody);","somebody의","somefunc","somefunc()","somefunc();","somelib","somelib.thing;","someth","sometyp","sometype();","sometype,","somevalue:","somevar","somevar:","somewhat","sort","soundness)","sourc","source(vinil","source,","source.search(substring);","sourcemap","sourcemaps');","sourcemaps도","sourcemaps에","sourcemaps이","sourcemap에","sourcemap을","sourceroot","spacerepeatingpadd","span)","spanish:","speaking,","special","specialgreet","specif","specifi","specified,","spot","spread","spread에는","sq","squar","square,","square.color","square.penwidth","square.sidelength","squareconfig","squareconfig):","squareconfig);","squareconfig가","squareconfig은","squareconfig의","squareopt","squareoptions은","square를","src","src.search(sub);","src/","src/greet.t","src/greet.ts를","src/main.ts의","src/views의","src:","src에","src와","src의","stage","stand","standardgreet","start","startup.cs에서","state","state:","stateless","statement","statement:","statements)","state가","state의","static","staticzipcodevalidator.t","statu","status.ready;","step","step...\"","steps)","still","strategies)","stream","stream');","stream에","stream을","strict","strict\"","strict\"을","stricter","strictfunctiontyp","strictfunctiontypes이","strictnullcheck","strictnullchecks가","strictnullchecks도","strictnullchecks를","strictnullchecks에서","strictnullchecks와","strict를","string","string\";","string)","string),","string).length;","string):","string);","string,","string.prototyp","string.prototype.","string.prototype.match","string.prototype.replac","string.prototype.search","string.prototype.split","string;","string;)","string[]","string[])","string[],","string[];","string]:","stringarray","stringarray;","stringarray이","stringnumer","stringnumeric.add","stringnumeric.zerovalu","stringpadd","strings)","strings.foreach(","strings:","stringvalid","stringvalidator;","string}'입니다","string});","string},","string같은","string과","string으로","string은","string을","string의","string이","string인","string입니다.","stripintern","stripinternal[1]","strlength:","strong","strongli","structur","student","student(\"jane\",","studio","studio는","studio에","studio에게","studio에서","studio와","style","style.","sub)","sub:","sublim","submit","substring:","subtl","subtyping)\"라고도","successfulli","such","sudo를","suffix","suit","suit\";","suit:","suits:","suits[pickedsuit],","sum","summatrix","summatrix(matrix:","super(\"account","super(\"rhino\");","super(\"veri","super();","super()를","super(name);","super(value);","super.move(distanceinmeters);","support)","suppressexcesspropertyerror","suppressimplicitanyindexerror","sure","surface.","swim();","switch","switch가","switch블록","sym","sym1","sym2","sym3","sym3;","symbol","symbol(\"format\");","symbol(\"key\");","symbol(\"required\");","symbol();","symbol,","symbol.hasinst","symbol.isconcatspread","symbol.iter","symbol.match","symbol.replac","symbol.search","symbol.speci","symbol.split","symbol.toprimit","symbol.tostringtag","symbol.unscop","symbols)","symbol은","symbol이","symlinked된","symlinks를","sync.","synonym","system","system.collections의","system.config({","system.import(\"./zipcodevalidator\").then((zipcodevalidator:","system.import('scripts/main').then(null,","system.js)","system.js의","system.register([\"./mod\"],","system:","systemj","systemjs를","system을","s가","t","t();","t)","t):","t,","t;","t[]","t[]):","t[k]","t[k],","t[k].get();","t[k][]","t[k]는","t[k]를","t[p]","t[p];","t[p]가","t[p]의","t[string]은","t]:","t]?:","tag","tag:","tag라고","take","target","target,","targets.","task","teach","techniques)","templat","template.","template1.t","template:","tempor","test","test(c,","test(c:","test.t","test:","testcalculator.t","testprogrammercalculator.t","tests에","text","textbox","text를","that,","thecitythatalwayssleeps()","them\");","them.","themselv","thename;","thename으로","thename을","theory:","there!\";","there\";","there'","they'r","thing","things)","things.","things:","this)","this.","this._fullnam","this._fullname;","this._i","this._p0","this._p0;","this._p1","this._p1;","this._x","this._x;","this._y;","this.activate();","this.bas","this.curr","this.current);","this.current;","this.currenttim","this.depart","this.evaluate();","this.evaluateoperator(this.operator,","this.fullnam","this.getdistance({","this.greet","this.greeting);","this.greeting;","this.hello","this.info","this.info를","this.isact","this.isdispos","this.isdisposed),","this.memori","this.memory,","this.memory;","this.model.compiler;","this.nam","this.name);","this.oper","this.processdigit(char,","this.processoperator(char);","this.prop","this.props.b;","this.props.children","this.props는","this.scale;","this.suit","this.suits[pickedsuit],","this.valu","this.value;","this.x;","this.y;","this:","this;","this가","this는","this를","this에","this와","this을","this의","those","those,","though","though,","three","three.","three:","three?:","threestringprop","through\"","throw","thumb","tick()","tick();","time","time\");","timeout?:","timestamp:","title:","title?:","tock\");","today,","tofixed는","together)","tolowercase()와","tom.move(34);","tom.move(34)를","tom:","tommi","tom은","toobservable():","tool","tool.","tools)","toolsvers","top","topics)","toprimit","total","tr","traceresolut","traceresolution을","tradit","trail","transit","tree","tree;","tri","triangl","triangle;","triangle과","triangle을","tricky.","true","true);","true,","true;","true}))","true로","true를","true와","ts","ts\");","ts.createproject(\"tsconfig.json\");","ts2307","ts2345:","ts:","tsc","tsconfig.json","tsconfig.json)","tsconfig.json:","tsconfig.json는","tsconfig.json를","tsconfig.json에","tsconfig.json에서","tsconfig.json에서만","tsconfig.json와","tsconfig.json은","tsconfig.json을","tsconfig.json의","tsconfig.json이라는","tsconfig.json파일에서","tsconfig.json파일은","tsconfig.json파일을","tsconfig.nostrictnull.json:","tsc를","tsc와","tsifi","tsify는","tslib로부터","tsproject","tsproject.src()","tsresult","tsresult.js.pipe(gulp.dest(\"built/local\"));","tsscript","ts로","ts를","turkish:","turn","tw","two","two:","two?:","type","type)","type))","type,","type.","type.\");","type:","typedpropertydescriptor)","typeerror(\"invalid","typeifi","typeof","typeroot","typeroots를","typeroots와","types)","types)에","types,","types.","typesciprt에서","typescript","typescript!\",","typescript!\"를","typescript\"","typescript\");","typescript\"가","typescript)","typescript,","typescript.","typescript.d.t","typescript@next","typescript@next가","typescriptadditionalflag","typescriptallowsyntheticdefaultimport","typescriptallowunreachablecod","typescriptallowunusedlabel","typescriptalwaysstrict","typescriptbaseurl","typescriptcharset","typescriptcompileblock","typescriptdeclarationdir","typescriptemitbom","typescriptemitdecoratormetadata","typescriptexperimentalasyncfunct","typescriptexperimentaldecor","typescriptforceconsistentcasinginfilenam","typescriptgeneratesdeclar","typescriptimporthelp","typescriptinlinesourc","typescriptinlinesourcemap","typescriptisolatedmodul","typescriptjsxemit","typescriptjsxfactori","typescriptlib","typescriptmaproot","typescriptmodulekind","typescriptmoduleresolut","typescriptnewlin","typescriptnoemithelp","typescriptnoemitonerror","typescriptnofallthroughcasesinswitch","typescriptnoimplicitani","typescriptnoimplicitreturn","typescriptnoimplicitthi","typescriptnoimplicitusestrict","typescriptnolib","typescriptnoresolv","typescriptnostrictgenericcheck","typescriptnounusedloc","typescriptnounusedparamet","typescriptoutdir","typescriptoutfil","typescriptpreserveconstenum","typescriptpreservesymlink","typescriptreactnamespac","typescriptremovecom","typescriptrootdir","typescriptsamples/jspm","typescriptskipdefaultlibcheck","typescriptskiplibcheck","typescriptsourcemap","typescriptsourceroot","typescriptstrict","typescriptstrictfunctiontyp","typescriptstrictnullcheck","typescriptstripintern","typescriptsuppressexcesspropertyerror","typescriptsuppressimplicitanyindexerror","typescripts는","typescripttarget","typescripttoolsversion이","typescript가","typescript는","typescript는createcardpicker가","typescript로","typescript를","typescript보다","typescript에","typescript에는","typescript에서","typescript에서는","typescript에서도","typescript에서의","typescript와","typescript의","typescript처럼","typestrong/grunt","types를","types을","types의","type과","type에서","type은","typic","typing)\"","typing)\"이라고","typing)에","typings에서","typings은","typings을","typings의","t}","t는","t를","t에","t와","t으로","t의","t이며","u","u)","u):","u:","uglifi","uglify');","uglify는","uglify를","uglify와","uielement","uielement();","uielement.addclicklistener(h.onclickbad);","uielement.addclicklistener(h.onclickgood);","uint32array","ui컨트롤의","ui템플릿","umd","umd)","umd,","umd.","umd를","umd입니다.","uncheck","uncondit","undefin","undefined'에","undefined)","undefined);","undefined;","undefined}","undefined가","undefined는","undefined라는","undefined로","undefined를","undefined와","undefined이","undefined입니다.","under","understand","union","union.","unions)","unions,","unions은","unions합니다;","unknown","unknownprop이","unless","unproxify(proxyprops);","unproxify(t:","unresolv","unspecifi","until","unus","unusable:","up","up,","updat","url","url.parse(\"http://www.typescriptlang.org\");","url;","us","us.","usag","use.","used,","used.","usedefaultfiles와","user","user\";","user.","users.","usestaticfil","using,","usual","utcoffset():","utcoffset(b:","utf","util","util\");","v","v;","valid","validate(target:","validation.lettersonlyvalidator();","validation.lettersonlyvalidator)와","validation.stringvalidator;","validation.t","validation.zipcodevalidator();","validation라는","validator();","validator.isacceptable(s)","validator.zipcodevalidator();","validators)","validators:","validators[\"lett","validators[\"zip","validators[name].isacceptable(s)","validators[name].isacceptable(s);","validator를","valu","value)","value,","value.","value:","value;","values)","values,","values:","vanilla","var","variabl","variable)을","variable,","variables)","variables.","varied.","varieti","var보다","var에","var와","verbose:","verbose?:","veri","version","via","view","view1.t","view2.t","vinyl","vinyl으로","visual","visualstudio2015","visualstudio에","void","void)","void):","void,","void;","void>((e:","void가","void는","void로","void를","void에","void와","void이기","volume:","volume과","vs","vs.","vs2015","vs2015의","vs2017","vs2017의","vscode","vsdevmode.ps1","vs를","vs와","w","wait","want","warn","warnuser():","wasn't","wat?","watch","watchedbrowserifi","watchedbrowserify.on(\"log\",","watchedbrowserify.on(\"update\",","watchifi","watchify(browserify({","watchify,","watchify가","watchify로","watchify를","watchify에","way","way,","way.","way:","we'll","we'v","web","webpack","webpack.config.j","webpack에","webpack으로","webpack은","webpack을","webpack의","webpack이","webwork","well","well.","well.\");","whatev","whenev","wherea","whether","whichev","wholeobject;","wholeobject의","whose","why:","widget","widget,","widget;","widget[]","widget[];","width","width:","width?:","width가","wildcard","window","window,","window.creategreet","window.onmousedown","window.somenam","window로","window를","window보다는","with:","within","without","won't","woof!');","word와","work","works.","world","world!","world!\";","world\"","world\");","world\",","world\";","world.","worth","write","write:","written","written,","wrong","wrote","www.myget.org에서","wwwroot","wwwroot에","x","x(\"hello\");","x()","x();","x(42);","x(y);","x)","x);","x,","x.","x.diff(\"something\",","x.length);","x.push(\"string\");","x.push(1);","x.tofixed());","x.z","x:","x;","x[3]","x[6]","xdist","xml","x가","x는","x를","x에","x와","x의","y","y()","y)","y));","y,","y.push(\"string\");","y.push(1);","y:","y;","y?)","y?:","ydist","ydist)","ye","year","yehuda","yike","you'd","you'll","you'r","you.","yours,","you’ll","you’r","you’v","y가","y는","y에","y에는","y에서","y와","y의","z","z)","z:","z;","z]+$/;","za","zcv","zcv();","zebra","zerovalue:","zh","zip","zip();","zip)","zipcodevalid","zipcodevalidator();","zipcodevalidator.numberregexp.test(s);","zipcodevalidator.t","zipcodevalidator.zipcodevalidator();","zipcodevalidator:","zipcodevalidator;","zone","zoo","zoo:","zookeep","zookeeper;","{","{\"thi","{(arg:","{[\"foo\",","{a:","{a:number}에","{bootstrap}","{component}","{height:","{i","{myapp}","{mymodel}","{name:","{new():","{number","{number}","{props.compiler}","{props.framework}!;","{red","{red,","{string}","{suit:","{this.props.compiler}","{this.props.foo}","{this.props.framework}!;","{value:","{x:","{y}","{zipcodevalid","{{a:","{{getcompiler()}}`","{}","{})","{}));","{},","{};","{}가","{}로","{}를","{}을","{}이지만","{를","|","|,","||","}","}\"","}'","}'.`);","}(this,","})","})();","})(enum","})(function","}));","}).plugin(tsify));","}):","});","})}","})로","},","}.","}:","};","}[]):","}],","}];","}`);","}를","}으로만","}을","}이며","}인","}입니다.객체의","~","~/src/proj/gulpfile.j","~~~~~~~","~~~~~~~~~~~","~~~~~~~~~~~~~~~~","—","“exclude”를","“files”","“files”을","∘","│","└─","└──","└───lib","└───src","└───typescript","├─","├──","├───node_modul","►","가","가깝게","가능","가능성이","가능하거나","가능하게","가능하다는","가능하다면","가능하지만","가능한","가능한(open","가능할","가능합니다.","가능합니다.default","가능합니다.의미는","가능해야","가독성","가독성을","가드","가드(type","가드.","가드는","가드로","가드를","가드에","가드와","가드임을","가르쳐줄","가상","가시성","가이드","가이드는","가이드를","가이드에서는","가장","가정됩니다.","가정을","가정하겠습니다.","가정하고","가정하며","가정할","가정합니다.","가정합니다.null","가정합니다.간단히","가정합니다.예를","가정합니다.즉","가정해","가져","가져가면","가져야","가져야합니다.","가져오고","가져오기","가져오기를","가져오는","가져오도록","가져오려고","가져오려면","가져오지","가져온","가져온다는","가져올","가져옵니다.","가져와","가져와서","가져와야","가져왔습니다.\"react\"","가지","가지가","가지게되고","가지고","가지고있기","가지기","가지는","가지를","가지며","가지므로","가진","가질","가질뿐만","가질수","가짐으로써","가집니다","가집니다.","가집니다.void와","가집니다.실제로","가집니다.하나는","가짜","각","각각","각각에","각각의","각기","간","간결하다는","간단하게","간단하고","간단하지만","간단한","간단합니다.","간단합니다.가장","간단합니다.다음","간단합니다.예를","간단합니다:","간단히","간략하게","간섭하고","간에","간의","간접","간주되어야","간주되지","간주된다는","간주됩니다","간주됩니다.","간주됩니다.array,","간주됩니다.구체적으로","간주됩니다.몇","간주됩니다:","간주하며","간주할","간주합니다.","간주합니다.그","간주합니다.또한","간주합니다.사실상","간주합니다.소수의","간주합니다.클래스에","감사하겠습니다","감싸고","감싸기","감싸져","감쌀","감지하는","감지합니다.모듈","값","값)","값과","값네임스페이스","값도","값들을","값만","값에","값에만","값에서","값으로","값은","값을","값의","값이","값이기","값입니다.","값입니다.이","값입니다.즉","강력하고","강력한","강요합니다.문자열","강제가","강제로","강제합니다.","갖게됩니다.","갖는","갖는)","갖도록","갖습니다.","갖습니다.\"include\"와","갖습니다.react","갖습니다.지원되는","갖지","갖춘","갖춰야","같기","같습니다","같습니다.","같습니다.인터페이스는","같습니다:","같아","같아야","같으므로","같은","같을","같이","같지만","개념","개념과","개념에","개념은","개념을","개념이","개념이지만","개발","개발을","개발자","개발자가","개발자는","개발자들도","개발자들에게는","개발자들은","개발자들이","개발자에게는","개발할","개별적으로","개수의","개요","개요를","개의","개체가","객체","객체가","객체는","객체도","객체로","객체를","객체마다","객체만","객체에","객체에는","객체에서","객체에서도","객체와","객체와의","객체의","객체인","객체입니다.","객체입니다.이것은","객체처럼","거슬러","거에요!","거의","거쳐","거치지","거칠","거칩니다.객체","걱정을","걱정하지","건너뛰기[default","건너뛸","건너뜁니다.","걸","걸맞은","걸음","걸쳐","걸쳐있을","걸프","걸프,","검사","검사(excess","검사가","검사기","검사기는","검사기를","검사나","검사는","검사되기","검사되며","검사를","검사만","검사에","검사에는","검사에서","검사와","검사을","검사의","검사하기","검사하는","검사하도록","검사하여","검사할","검사합니다.","검사합니다.typescript","검사합니다.그","검사합니다.그런","검사합니다.타입을","검사해야","검사했습니다.이","검색","검색됩니다.","검색량과","검색하세요","검색한","검색할","검색합니다.","검색합니다.node_modul","검입니다.","겁니다.","겁니다.특정","겁먹지마세요","것","것과","것과는","것도","것들에는","것들은","것들을","것들이","것에","것에서","것으로","것은","것을","것이","것이고","것이다.이","것이다.차이점을","것이든","것이라고","것이라면","것이므로","것이었습니다.그것은","것인지를","것입니다","것입니다!\"hello","것입니다).","것입니다.","것입니다.entri","것입니다.javascript","것입니다.javascript에서","것입니다.multiply는","것입니다.new를","것입니다.pickcard가","것입니다.각","것입니다.게다가","것입니다.결합","것입니다.그러나","것입니다.그리고","것입니다.다른","것입니다.다음에","것입니다.다음장에서는","것입니다.다행히도","것입니다.대신","것입니다.또는","것입니다.또한","것입니다.만일","것입니다.모듈","것입니다.모듈에는","것입니다.모듈의","것입니다.반대로,","것입니다.반면에","것입니다.변수는","것입니다.생성자에","것입니다.선언전에","것입니다.앞서","것입니다.언제","것입니다.여기에서는","것입니다.여러분은","것입니다.열거형은","것입니다.예를","것입니다.이","것입니다.이것은","것입니다.이것을","것입니다.이는","것입니다.이러한","것입니다.이렇게하면","것입니다.이를","것입니다.이제","것입니다.전역","것입니다.종종","것입니다.즉","것입니다.첫","것입니다.클래스와","것입니다.타입","것입니다.타입에","것입니다.파일은","것입니다.파일이","것입니다.현재의","것입니다:","것조차도","것처럼","게시물은","격리","결고","결과","결과가","결과는","결과로","결과를","결과와","결과적으로","결과적인","결국","결론을","결정.","결정된","결정됩니다.","결정됩니다.다시","결정됩니다.단일","결정됩니다.사용할","결정됩니다:","결정하기","결정하는","결정할","결정합니다.jsx.elementchildrenattribute는","결코","결합","결합(union)을","결합되어","결합된","결합될","결합됩니다.이러한","결합을","결합하는","결합하세요","결합하여","결합한","결합할","결합합니다.","결합합니다.따라서","겹칠","경고","경고가","경고를","경고합니다.","경고합니다.이","경고했을","경로","경로.","경로가","경로는","경로로","경로를","경로에","경로와","경로의","경로인","경로인지","경로인지에","경로일","경우","경우(\"modulea\"의","경우,","경우:","경우x의","경우가","경우는","경우도","경우를","경우에","경우에는","경우에는)","경우에는,","경우에도","경우에만","경우와","경우의","경우입이다.","경우조차도","경험을","계산)","계산기","계산기가","계산기로","계산기를","계산기의","계산되지","계산된","계산된(computed)","계산된,","계산을","계산하는","계속","계속합니다.일치하는","계속해서","계약을","계층","계층,","계층에","계층을","계층이","계층적","계층적으로","계획을","계획이라면","고급","고급스럽게","고려되지","고려됩니다.","고려됩니다.이","고려하고","고려하세요)","고려하세요.","고려해보세요.","고려해보세요.또한","고려해보세요.빌드","고려해야","고려해야합니다.여기서는","고려했으며","고맙게도","고유한","고유합니다.","고유합니다.인터페이스는","고유해야","고전적인","고정된","고정시킬","고쳐야하는지.","고침","고통스럽습니다.다행스럽게도,","고통이","고통이었지만","골격으로","곳과","곳에","곳에서","곳은","곳을","곳이","곳이라면","곳입니다:","공개에서","공백","공백이","공식","공식적으로","공유됩니다.","공유하기","공유하는","공유하지만","공유한다는","공유합니다.","공유합니다.lastname의","공통","공통적인","공통점을","공통점이","공학의","과","과도하게","과정에서","과정이","관계","관계는","관계를","관계시키는","관계없이","관계의","관대하기","관대하지","관대한","관련","관련).","관련된","관련사항","관련이","관련하여","관리되는","관리에","관리하는","관리합니다.프로젝트에","관리해야합니다.","관심이","관점에서","관찰,","관찰하거나","관찰하는","관찰할","관한","괄호","괄호(<>)","괄호(<>)로","괄호로","괄호를","광범위하게","광범위한","괜찮습니다.","괜찮은","괜찮을","굉장히","교차","교차(intersection)","교체합니다.","교체합니다.앞의","교환","구글","구문","구문과","구문에","구문으로","구문은","구문을","구문이","구문입니다.나중에","구문입니다:","구별되는","구별하기","구별하는","구분된","구분에","구분하기","구분하지","구분할","구성","구성과","구성됩니다.","구성됩니다.이","구성요소가","구성원","구성을","구성하고","구성하는","구성하여","구성하지","구성할","구성합니다.캡처된","구성해야","구성해야합니다:","구조","구조,","구조가","구조로","구조를","구조에","구조와","구조의","구조입니다.","구조적","구조적인","구조화","구조화를","구조화하기","구조화하는","구조화해야","구체적으로","구체적인","구체적일","구축","구축되는","구축을","구축하는","구현","구현되기","구현되지","구현된","구현에","구현에서","구현은","구현을","구현이","구현체로","구현하는","구현하여","구현한다고","구현할","구현합니다.","구현해야","국제화","굵은","궁금해","권장","권장되지는","권장하지","권장하지만","권한","권한을","권한이","규모에서","규칙","규칙과","규칙에","규칙에서","규칙은","규칙을","규칙이","규칙입니다.","그","그것들은","그것들을","그것들이","그것은","그것을","그것의","그것이","그냥","그대로","그들은","그들이","그래도","그래서","그러기","그러나","그러면","그런","그런트","그럴듯한","그럼","그럼에도","그렇게","그렇기","그렇다면","그렇습니다.","그렇지","그렇지는","그레이션에는","그룹","그룹으로","그룹을","그룹의","그룹이며","그룹화할","그리고","그리고.d.ts를","그에","그저","근본적인","글로벌","글로벌으로","글에는","금지되어","기계적으로","기능","기능들을","기능에","기능으로","기능은","기능을","기능이","기능이며","기능이지만","기능입니다.","기다리고","기다리지","기대하는","기대할","기대합니다.","기록하고","기록하도록","기록하여","기록할","기록합니다.이","기명","기반","기반으로","기반으로합니다.구조적","기반의","기법","기법을","기법의","기본","기본값","기본값과","기본값으로","기본값은","기본값은any입니다.","기본값을","기본이","기본이며","기본적으로","기본적으로(위에서","기본적으로는","기본적인","기본적인(위에서","기분","기사를","기술을","기술적으로","기술하고,","기술하지","기술한","기억을","기억하세요.","기억하세요?settimeout에","기억한다면","기억할","기억해야","기여","기여할","기존","기존의","기준","기준으로","기초적인","기타","길이를","깃헙","깊숙이","깊숙하게","깊은","깊이.","까다로울","꺼져","꺾쇠","꽤","끝나면","끝난","끝날","끝납니다.","끝납니다.작성된","끝냈나요?","끝없는","끝에","끝의","나","나갑니다:","나누어","나눌","나뉩니다.","나뉩니다:","나란히","나머지","나머지는","나열","나열된","나열합니다.","나열해야","나오는","나올","나옵니다:","나은","나중에","나타나는","나타날","나타납니다(여기서는","나타납니다.","나타납니다.또한","나타내기","나타내는","나타낼","나타냅니다.","나타냅니다.tsconfig.json","나타냅니다.객체","나타냅니다.예를","나타냅니다.이것을","난독화로","남겨","남겨놨습니다","남겨졌습니다.","남겨진","남아있어","내","내가","내고","내려야","내보내기","내보내기\"가","내보내기(re","내보내기는","내보내기에","내보내는","내보내도록","내보내지","내보내지만","내보낸","내보낸다고","내보낼","내보냅니다.","내보냅니다.소스","내부","내부(inner)","내부가","내부에","내부에서","내부에서만","내부의","내에","내에서","내용","내용:","내용만","내용은","내용을","내용의","내용이","내의","내장","내장객체는","내장된","내키는","낸다는","너무","너무나","넓은","넘겨주면","넘겨줄","넘기면","넘길","넣습니다:","넣어","넣어야합니다.","넣으면","네가지","네이밍은","네이밍을","네이티브","네임","네임스페이스","네임스페이스(이전의","네임스페이스,","네임스페이스가","네임스페이스는","네임스페이스로","네임스페이스를","네임스페이스에","네임스페이스에서","네임스페이스에서만","네임스페이스와","네임스페이스의","네트워크","노드","노드.이","노드에서","노드와","노드의","노드입니다.","노력을","노력하고","노력합니다:","노출되지","노출된","노출됩니다.","노출하므로","노출합니다.다시","노트","논리적","논리적으로","논의하겠지만","논의할","놀라운","놀랐을","높다는","높습니다.","높은","높을","높일","놓고","놓일","누군가","누락된","누르고","누릴","누출되는","눈치","눌러","눌러도","느껴질","느낄","느슨하면","는","는jsx.intrinsicelements에","는symbol.iter","능력에","다","다루게","다루고","다루기","다루는","다루었던","다루지","다룰","다룹니다.","다룹니다.이번에도","다르게","다르지만","다르지만,","다른","다를","다름","다릅니다.","다만","다소","다수를","다수의","다시","다양한","다운그레이드는","다운로드","다운로드.","다운로드할","다음","다음,","다음과","다음에","다음에서","다음으로","다음은","다음을","다음의","다음이","다이얼로그와","다할","다행스럽게도","다행히","다형성의","다형성의thi","다형성이라고","단","단계","단계가","단계는","단계를","단계에만","단계에서","단계의","단서는","단순하고","단순한","단순화할","단순히","단어를","단언","단언(assertion)을","단언(type","단언만","단언을","단위로","단일","단점","단점은","단점을","단지","단지string이","단축형태입니다.","단항","닫힌","달라집니다.","달러의","달리","달리).예를","달성하기","달아야","담당한다.","담은","당신은","당연합니다.대부분의","당장은","대규모","대답도","대답은","대로","대문자","대문자로","대부분","대부분,","대부분의","대비하여","대상","대상에","대상으로","대상을","대상의","대상이","대수롭지","대수의(algebraic)","대신","대신)를","대신node_modul","대신에","대신하는","대안","대안:","대응을","대응이","대응하는","대조적입니다.","대체","대체로","대체를","대체하는","대체하세요:","대체합니다.","대체합니다.일단","대하여","대한","대해","대해서","대해서는","대해서도","대해서만","대형","더","더욱","더이상","더한","던지는","던질","덜","덜어주기","덮어","덮어쓰게","덮어쓰기도","덮어쓰지","덮어씁니다.","덮어씁니다.따라서","덮어씌웁니다.typescript는","데","데는","데만","데이터","데이터는","데이터를","데이터에","데코레이터","데코레이터(@sealed)의","데코레이터가","데코레이터는","데코레이터를","데코레이터에","데코레이터에서","데코레이터와","데코레이터의","데코레이터입니다","데코레이팅","데코레이팅된","데코레이팅하는","덱을","도구","도구가","도구는","도구들","도구를","도구만","도구뿐만","도구와","도구의","도구입니다.","도달","도메인에","도와줍니다.기존","도움말을","도움이","도입","도입된","도입됨에","도입하기보다는","도입하는","도입하지","도입할","도입해야","도입했습니다.하위(children)는","독립된","독립적으로","독립적인","독자는","돌아가서","돌아와","돕기","동기","동기를","동시에","동안","동안,","동일하게","동일하다는","동일하므로","동일하지만","동일한","동일합니다","동일합니다).","동일합니다.","동일합니다.(즉","동일합니다.다른","동일합니다:","동일해야","동작에","동작은","동작을","동작하는지","동작하지만","동작합니다.","동작합니다.단","동적","동적으로","동적이고","동적인","동형","동형(homomorphic)이","동형(homomorphic)이기","동형(homomorphic)인","동형이","되고","되기","되는","되면","되므로","되었습니다.","되지","된","된다는","될","될것입니다)문자","됩니다","됩니다.","됩니다.js에서","됩니다.sourc","됩니다.새로운","됩니다.숙련된","됩니다.앞의","됩니다.예제","됩니다.이","됩니다.참조","됩니다:","두","두가지","두가지가","두가지입니다:","두개의","두고","두는","두면","두번째","두번째,","두번째는","두어야","두었습니다.","두지","둘","둘은","둘의","둘째,","뒤에","뒤에있는","드는","드문","드물기","들릴지","들어","들어,","들어:","들어가고","들어갑니다.","들어보겠습니다","들어있는","듭니다.특히","등)","등.)","등..)","등과","등록을","등으로","등을","등의","등이","등장하는","등장합니다.","디렉토리","디렉토리.","디렉토리가","디렉토리내의","디렉토리는","디렉토리로","디렉토리를","디렉토리부터","디렉토리에","디렉토리에서부터","디렉토리에의","디렉토리와","디렉토리의","디렉토리일때마다","디렉토리입니다.","디버거가","디버거를","디버그","디버깅","디버깅이","디버깅하는","디버깅할","따라","따라,","따라서","따라야","따라야할","따라와야","따르고","따르는","따르면,","따른","따릅니다.","따릅니다:","따옴표","따옴표(\")","따옴표(')를","딱","때","때,","때:","때가","때까지","때는","때때로","때떄로","때로는","때를","때마다","때만","때문에","때문이다.","때문입니다).그러나","때문입니다.","때문입니다.기본적으로","때문입니다.다음","때문입니다.생성자는","때문입니다.왜냐하면","때문입니다.이","때문입니다.이것은","때문입니다.이와","때문입니다.즉","때문입니다.함수가","때의","떄문입니다.","또","또는","또는string이","또한","똑같이","뛰어난","뜻은","뜻인지","뜻합니다.","라고","라고도","라는","라벨에","라벨은","라이브러리","라이브러리가","라이브러리는","라이브러리로","라이브러리를","라이브러리에","라이브러리에는","라이브러리에서","라이브러리와","라이브러리의","라인","라인:","라인에","라인에서는","라인의","라인이","라인이나","래핑된","래핑하는","래핑합니다.","런타임","런타임시","런타임시에","런타임시의","런타임에","런타임에는","런타임은","레벨","레벨에","레벨에서","레벨을","레벨의","레벨이거나","레이블에","레이아웃과","레이아웃은","레이아웃이","렉시컬","로","로그","로그했습니다.","로깅을","로더","로더는","로더들은","로더를","로더보다","로더에","로더에서","로더이며","로더인","로드","로드가","로드되기","로드된","로드됩니다.asp.net","로드됩니다.이","로드의","로드하는","로드하여","로드할","로드해야","로딩","로딩과","로직","로직에","로직은","로직을","로컬","로컬로","로컬에","로컬에서","로케일을","루트","루트가","루트에","루트임을","루프가","루프는","루프를","루프의","루프입니다:","를","리다이렉트합니다.","리뷰에서","리스트","리스트가","리스트를","리스트에","리스트에서","리스트에서도","리스트이고","리액트","리터럴","리터럴)","리터럴,","리터럴과","리터럴로","리터럴에","리터럴에는","리터럴은","리터럴을","리터럴의","리터럴처럼","리턴문를","리턴합니다.","리팩토링을","리팩토링해야합니다.","릴리즈","마무리합시다.","마세요","마세요!)","마세요\"","마술을","마우스","마우스를","마음이겠지만","마이","마이그레이션","마이너스","마지막","마지막에","마지막으로","마지막으로,","마찬가지로","마찬가지로,","마찬가지입니다.","마찬가지입니다.모듈의","마찬가지입니다.여기에서.","마찰을","마찰이","마치","막대(|)를","만","만드는","만든","만들","만들겠습니다.","만들고","만들기","만들기를","만들려고","만들면","만들어","만들어냅니다.","만들어야","만들어졌으며","만들어지고","만들었습니다.이","만들지","만듭니다","만듭니다.","만듭니다.“exclude”","만듭니다.여러","만듭니다.이","만듭니다.이것은","만듭니다.이것이","만듭니다.클래스를","만듭니다:","만약","만큼","만하면","많거나","많습니다","많습니다!)","많아지면","많은","많이","말아야","말하는","말하면","말하자면","말할","말합니다.","말합니다.이","말해서","말해줍니다.","맞게","맞는","맞닥뜨리면","맞습니다","맞지","맞추고","맞추는","맞춤형","매개","매개변수","매개변수(...nums)를","매개변수(default","매개변수(여기서는","매개변수가","매개변수가에","매개변수는","매개변수들을","매개변수들의","매개변수들이","매개변수라고","매개변수로","매개변수를","매개변수에","매개변수와","매개변수의","매개변수입니다:","매개변수처럼","매기기를","매니저","매니저)","매우","매우(극단적으로)","매칭","매핑","매핑(revers","매핑과","매핑되어야합니다.","매핑된","매핑은","매핑을","매핑의","매핑하세요.","매핑합니다.","맨","맵","맵과","맵에","맵으로","맵을","맵이","맵핑","맵핑이","머리말에","먼저","멈추는","멈추지는","메모","메모:","메서드","메서드,","메서드object.prototype.tostring로","메서드가","메서드는","메서드로","메서드를","메서드에","메서드에도","메서드와","메서드을","메서드의","메서드입니다.","메세지","메세지를","메소드를","메시지가","메시지는","메시지를","메이저","메커니즘","메커니즘에","메커니즘을","메커니즘의","메커니즘이","메타","멤버","멤버(static","멤버가","멤버는","멤버도","멤버들에","멤버들은","멤버들을","멤버들이","멤버로","멤버를","멤버만","멤버에","멤버에는","멤버에만","멤버와","멤버을","멤버의","멤버이기","멤버이며","멤버입니다.","멤버입니다.리터럴","멤버조차도","명령","명령과","명령문을","명령줄에서","명백하기는","명사적인","명시된","명시적","명시적(또는","명시적으로","명시적인","명시하기","명시하려면","명시해야","명시해야합니다.","명시해주지","명심하세요","명심하세요:","명제","명제로","명제입니다.명제는","명칭이","명확하게","명확하고","명확한","몇","몇가지","몇개의","몇몇","모던하게","모델링","모델링하기","모델링하는","모델링할","모델에서","모델은","모두","모두로","모두를","모두에서","모듈","모듈\")를","모듈\"은","모듈,","모듈과","모듈로","모듈만","모듈별","모듈성","모듈에","모듈에는","모듈에서","모듈은","모듈을","모듈의","모듈이","모듈이라고","모듈인","모드","모드가","모드는","모드로","모드를","모드에서는","모든","모르는","모르지만","모를","모릅니다.이렇게","모릅니다:","모방하는","모방하려고","모방합니다.이를","모습의","모아서","모을수","모일","목록","목록.","목록과","목록내에","목록보기","목록에","목록에서","목록에서만","목록은","목록을","목록의","목록이","목록입니다.","목록입니다.가능한","목적상","목적을","목적이","목적인","목표로","못하고","못하는","못하면","못한","못한다면","못합니다.","못합니다.이런","무단","무덤을","무상태","무슨","무시됩니다.","무시됩니다.새","무시하는","무시할","무언가를","무엇을","무엇이","무엇이었는지에","무엇인지","무엇일까요?","무엇입니까?","무엇입니까?\"라고","무한적인","무한적입","묵시적인","묶는","묶어서","묶어야한다는","묶인","문","문맥적으로","문서","문서를","문서에","문서에서","문서와","문서을","문서의","문안에","문에","문은","문을","문자","문자로","문자를","문자열","문자열(string)","문자열,","문자열과","문자열에","문자열에서","문자열은","문자열을","문자열의","문자열이","문자열이어야","문자열인","문자열입니다.","문자와","문장과","문장을","문장이","문제","문제가","문제는","문제들은","문제를","문제없는","문제없이","문제점은","묻는","묻습니다.이것은","물건에","물론","물리적","뭐든","미래의","미리","미묘하며","미묘한","미치는","미치는지를","미치지","미칩니다","믹스에","믹스인","믹스인에","믹스인에서","믹스인으로","믹스인을","믹스인의","믹스인이나","믹싱하여","믿어,","밀리","밀접한","및","바깥에서","바꾸기","바꾸는","바꿀","바꿔","바꿔보겠습니다.제네릭","바꿔서","바꿔야","바람직하지","바람직한지를","바랍니다.","바로","바보같은","바운드","바이너리","바이트","바인딩","바인딩에서","밖에","밖에도","밖에서","반대로","반대의","반대일","반대입니다.배열을","반드시","반면","반면에","반복","반복되는","반복마다","반복문","반복문의","반복자","반복자는","반복자를","반복적으로","반복하며","반복할","반복합니다.반복되는","반복해서","반영되지","반영하기","반영합니다.","반환","반환값이","반환되는","반환된","반환될","반환문을","반환문입니다.상황적","반환하거나","반환하기","반환하는","반환하도록","반환하면","반환하지","반환한다는","반환할","반환합니다","반환합니다.","반환합니다.사용자가","반환합니다.숫자","반환했을","반환횔","받게","받고","받기","받습니다.","받습니다.typescript는","받아","받아들일","받을","받지","발견","발견되는","발견되지","발견할","발견합니다.오류를","발명가","발생시키지","발생시킵니다.","발생으로","발생하기","발생하는","발생하는지","발생하여","발생하지","발생한","발생할","발생합니다","발생합니다.","발생합니다.createcardpicker에","발생합니다.employee도","발생합니다.그러나","발생합니다:","발생해야합니다","발생해야합니다.","발전시켜","발휘되는","방금","방문할","방법","방법과","방법도","방법에","방법에는","방법으로","방법으로는","방법으로도","방법은","방법을","방법이","방법이기도","방법이다.","방법이며","방법이지만","방법임을","방법입니다.","방법입니다.type","방법입니다.typescript에서는","방법입니다.매개변수","방법입니다.예를","방법입니다.이","방법입니다.이것은","방법입니다.이러한","방법입니다.하지만","방식에","방식으로","방식으로든","방식을","방식이","방지하기","방지하는","방지하려는","방지할","방지합니다.","방출","방출되는","방출되며","방출된","방출될","방출됩니다.","방출에는","방출을","방출하고","방출하기","방출하지","방출할","방출합니다.","방출했습니다.이","방향\"에서도","방향은","배열","배열(union","배열로","배열에는","배열은","배열을","배열의","배열이","배열이며","배우는","배우지","배워야","배웠고","배웠습니다.","배치","배치하세요.","배포","배포됩니다.다음과","배포하기","배포하는","백","백(option","백그라운드","백틱","버그가","버그는","버그를","버그의","버그이지만","버그입니다.즉","버리게","버블링됩니다.","버전","버전:","버전과의","버전에","버전에서","버전에서는","버전으로","버전을","버전의","버튼으로","벅차다고","번","번들","번들(묶어서)로","번들(예:","번들로","번들링","번들링(묶는)하는","번들링을","번들링이나","번들링하는","번들을","번만","번에","번역","번역가이드","번역가이며","번역도","번역을","번역이","번역하는","번역할","번역했습니다.typescript","번째","번째,","번째는","번째로","번호를","범위","범위를","범위에","범하는","벗어나지만캡처의","베이스를","베이스에서","변경","변경되었습니다.\"내부","변경되었습니다.\"내부(internal)","변경되지","변경될","변경을","변경하고","변경하면","변경하십시오","변경하여","변경하지","변경하지도","변경할","변경합니다","변경합니다.이제","변경해야","변경해야합니다.가령","변경했습니다.편리하게도","변수","변수(type","변수).이러한","변수,","변수가","변수는","변수는y에","변수들을","변수로","변수를","변수에","변수에는","변수에도","변수에서","변수에서도","변수와","변수의","변수인","변수입니다.매우","변이들의","변하지","변형","변형되어야","변형시키지","변형을","변형입니다.이것은","변화는","변화로","변환","변환(타입캐스팅)과","변환되는지","변환됩니다.로더는","변환은","변환을","변환의","변환하기","변환하는","변환하려는","변환한","변환할","변환합니다","변환합니다.","변환합니다.예를","변환합니다.즉","변환해봅시다.","별","별개의","별개이지만","별도로","별도의","별종","별칭","별칭(alias)","별칭)를","별칭을","병합","병합\"은","병합'","병합'이라는","병합되는","병합되는지","병합되며","병합되어","병합되어야","병합되지","병합된","병합될","병합됩니다.","병합됩니다.그러나","병합됩니다:","병합은","병합을","병합이","병합입니다.가장","병합하기","병합하는","병합하려면","병합하십시오","병합할","병합합니다.네임","보강하는","보강하지","보게해야","보겠습니다.","보겠습니다.typescript는","보겠습니다.먼저src/components에","보겠습니다.이것은","보겠습니다:","보고","보고된","보고하지","보고합니다.","보고합니다.상속","보냅니다","보는","보다","보다는","보려면","보면","보면,","보세요.","보세요:","보수하기","보시길","보았을","보여","보여야","보여야합니다.내장","보여주지만","보여줄","보여줍니다","보여줍니다.","보여줍니다.이","보여줍니다.코드가","보여줍니다:","보이는","보이는지","보이지","보일","보입니다.기존의","보장되는","보장된","보장하는","보지","보통","보통의","보편적인","복사","복사본을","복사하거나","복사하고","복사하는","복사하세요.식별자","복사할","복사합니다.런타임에","복사해야","복잡하지","복잡한","복잡합니다.","복잡합니다.배열은","복잡합니다.이전에","본","본문","본문에","본문에서","본문을","본문이","본질적으로","볼","봅시다","봅시다.","봅시다.app.ts는","봅시다.settimeout은","봅시다.그러면","봅시다.이","봅시다:","봉인합니다.다음은","부가적인","부동","부르겠습니다.","부르는","부릅니다.","부릅니다.다른","부릅니다.매개변수","부분","부분과","부분에","부분에서는","부분은","부분을","부분의","부분이므로","부분인지","부분적으로","부수","부여","부여하는","부여합니다.전개는","부여해야","부울","부재도","부적절하지만","부적절한","부적절함","부정확한","부족하여","부터는","분류된다는","분류됩니다.jsx.element","분리된","분리하는","분리해야","분명해집니다.","분명히","분석","분석됩니다.","분석을","분석해보겠습니다.","분할","분할하는","불가능합니다.","불가능합니다:","불과합니다.","불구하고","불구하고,","불러오기","불리하여","불림)를","불립니다.네임스페이스를","불법이라는","불법임을","불법입니다;","불변","불변이며","불투명합니다","불평하는","불필요한","불필요합니다.","불행히도","붙여","붙여넣기","붙여야","붙은","붙을","붙이겠지만","붙입니다.","붙입니다.반대로","뷰는","브라우저가","브라우저들은","브라우저로","브라우저에","브라우저에서","브라우저와","브랜치에","브랜치의","브레이크포인트가","브레이크포인트을","블랙박스","블럭","블록","블록에","블록의","블록이","블록처럼","비","비교","비교됩니다.정적","비교를","비교적","비교하는","비교하며","비교할","비구조화","비구조화는","비구조화된","비구조화를","비구조화시","비구조화의","비구조화입니다.전체","비구조화처럼","비구조화하는","비례해서","비롯된","비롯될","비밀스러운","비상대적인","비상수(non","비슷하게","비슷하게,","비슷하지만","비슷한","비슷합니다).","비슷합니다.","비슷합니다.제네릭","비슷합니다:","비앰비언트","비어있을","비용을","비워","비해","비활성화합니다.","빌드","빌드가","빌드는","빌드를","빌드에","빌드와","빌드의","빌드하는","빌드한","빌드할","빌드합니다.","빠르게","빨간","빨간선이","빨리","빼먹는","뻬먹지","뼈대를","뿐만","뿐이지만","뿐입니다.","뿐입니다.어떠한","사라지고","사라지려면","사람들은","사람들을","사람들이","사례들을","사본에","사상에","사실만","사실을","사실일","사실입니다.","사양에","사양을","사용","사용)","사용:","사용과","사용되고","사용되는","사용되는지","사용되도록","사용되든","사용되며","사용되어야","사용되지","사용된","사용될","사용됩니다","사용됩니다.","사용됩니다.typescript는","사용됩니다.때로는","사용됩니다.선택적","사용됩니다.세","사용됩니다.예를","사용됩니다.지원되는","사용됩니다.파일은","사용됩니다.한편","사용됩니다:","사용법을","사용법이","사용에","사용으로","사용은","사용을","사용이","사용자","사용자가","사용자는","사용자들은","사용자들을","사용자를","사용자에게","사용자에게는","사용자의","사용하거나","사용하겠지만","사용하고","사용하기","사용하기로","사용하기를","사용하기에","사용하는","사용하는것은","사용하는데,","사용하도록","사용하려고","사용하려는","사용하려면","사용하려면:","사용하며","사용하면","사용하므로","사용하세요","사용하세요.","사용하세요.\"rootdirs\"은","사용하세요.require.js의","사용하세요.만일","사용하세요.앞의","사용하십시오.","사용하여","사용하였습니다.","사용하지","사용하지만","사용한","사용한다.이러한","사용한다는","사용한다면","사용할","사용할지","사용할지를","사용합니다","사용합니다(즉시실행함수","사용합니다.","사용합니다.\"react\"","사용합니다.(주의사항","사용합니다.javascript와","사용합니다.package.json","사용합니다.typesciprt에서는","사용합니다.각","사용합니다.기본","사용합니다.내장","사용합니다.둘","사용합니다.따라서","사용합니다.때때로","사용합니다.스코프가","사용합니다.실용적인","사용합니다.여기서","사용합니다.이","사용합니다.이것는","사용합니다.이것은","사용합니다.자세히","사용합니다.즉","사용합니다.즉,","사용합니다.화살표","사용합니다:","사용해","사용해야","사용해야한다는","사용해야합니다.","사용했다면","사용했습니다.","사용했습니다.typescript에는","사용했어요.","사용했음을","사용했지만","사이에","사이의","사이즈","사이클을","사이트에","사이트에서","사이트의","사전에","사전을","사항:","사항에는","사항은","사항을","사항이","사항이라는","사항이며","사항이므로","사항이지만","삭제했는지","살펴","살펴보겠습니다","살펴보겠습니다.","살펴보겠습니다.node.js는","살펴보겠습니다.새로운","살펴보겠습니다:","살펴보고","살펴보면서","살펴보세요","살펴보세요.","살펴보았습니다.이것에","살펴본","살펴봅니다.","살펴봅니다.그러나","살펴봅니다:","살펴봅시다:","삽입됩니다.","삽입하여","삽입할","삽입해야","삽입해야하는지를","상관없이","상단에서만","상당히","상대","상대적","상대적으로","상대적이거나","상대적인","상대적인지","상대적입니다.","상세","상속","상속되는","상속받는","상속받습니다.여기서","상속받으며","상속받을","상속을","상속하고","상속하지는","상속하지만","상속할","상속합니다.즉","상수","상수들을","상수로","상수입니다.","상수입니다.이","상수입니다:","상수초기화되어야","상위","상응하는","상의하십시오.","상자에","상태\"의","상태는","상태로","상태를","상호","상황","상황에","상황에서","상황을","상황이","상황적","새","새로","새로고침","새로운","새롭게","색상","샘플","샘플:","샘플에서","샘플은","생각하는","생각하면","생각하세요.","생각하여","생각하지","생각할","생각해","생각해보세요.","생각해야합니다.word에서","생기는","생긴","생깁니다.이","생략","생략될","생략할","생성","생성기에","생성되면","생성된","생성된다는","생성됩니다","생성됩니다.","생성됩니다.이로","생성됩니다.코드에","생성자","생성자는","생성자를","생성자에","생성자에서","생성자와","생성자의","생성하겠습니다:","생성하고","생성하기","생성하는","생성하려고","생성하며","생성하면","생성하지","생성하지는","생성한","생성할","생성합니다","생성합니다.","생성합니다.생성된","생성합니다.여기에는","생성합니다.원시","생성합니다.이것은","생성합니다.타입","생성합니다.해당","생성합니다:","생성해","생성해야","생태계를","서로","서로를","서버","서버를","서브","서브타입","서비스","서수(순서가","섞일","선언","선언,","선언과","선언과도","선언되고","선언되기","선언되는","선언되어","선언되어야합니다.","선언되었음을","선언되었지만","선언된","선언될","선언됩니다.","선언됩니다.데코레이터는","선언됩니다.매개변수","선언됩니다.접근제어자","선언됩니다.클래스","선언됩니다.프로퍼티","선언들에","선언만","선언문은","선언없이","선언에","선언에는","선언에서","선언에서도","선언으로","선언으로부터","선언은","선언을","선언의","선언이","선언이든","선언이라고","선언입니다.데코레이터는","선언입니다.이전에","선언적입니다.","선언하기","선언하기전에","선언하는","선언하려면","선언하면","선언하였습니다.","선언한","선언한다는","선언할","선언합니다.","선언합니다.각","선언합니다.매개","선언합니다:","선언해야","선언해야합니다.","선언했습니다.그","선언했을","선정이나","선택","선택사항","선택사항으로","선택을","선택이","선택입니다.그러나","선택입니다.타입의","선택적","선택적으로","선택적인","선택적입니다.","선택적입니다.다음은","선택하게","선택하게하세요.","선택하고","선택하기","선택하는","선택하면","선택하세요.","선택하지","선택한","선택할","선택합니다.","선택합니다.사용자가","선택합니다.이러한","선택합니다:","선택해야하기","선택해야하는","선호도에","선호되는","선호해야","설계","설계되었거나","설계되었습니다.","설명","설명되어","설명된","설명을","설명하겠습니다.우리가","설명하겠습니다:","설명하고","설명하기","설명하는","설명하는데","설명하려면","설명한","설명한대로)","설명할","설명할까요?","설명합니다.","설명합니다.각","설명합니다.또한","설명합니다.용어에","설명합니다.즉","설명합니다.특히","설명해야","설정","설정과","설정되는","설정되면","설정되어","설정되었다고","설정되지","설정됩니다.","설정됩니다.이런","설정시","설정에","설정에서","설정은","설정을","설정이","설정하거나","설정하기","설정하는","설정하면","설정하세요.","설정하여","설정하지","설정할","설정합니다","설정합니다.","설정합니다.이러한","설정합니다.타입","설정합니다:","설정해","설정해야","설정했습니다.","설치","설치가","설치되어","설치되었으므로","설치된","설치를","설치하거나","설치하기","설치하는","설치하십시오","설치하십시오.gulp","설치하십시오.tsify는","설치하십시오.uglify의","설치하십시오.uglify처럼","설치하지","설치한","설치할","설치합니다.이","설치해야","설치했음을","성가시게","성공적으로","성공하면","성공하지","성공합니다.","성능이","세","세부","세부적으로","세이프","섹션","섹션에","섹션에서","섹션에서는","섹션으로","섹션은","섹션을","섹션의","소개","소개합니다.","소문자로","소속됩니다.이러한","소수","소스","소스가","소스는","소스를","소스맵을","소스에","소위","소프트웨어","소프트웨어의","속성","속성(own,","속성과","속성도","속성에","속성으로","속성은","속성을","속성의","속성이","속하지","손쉽게","손실을","수","수는","수단이","수도","수동으로","수를","수없는","수에","수와","수의","수있는","수정","수정된","수정하고","수정하기","수정하면","수정하세요:","수정할","수정합니다.","수정합니다:","수정합시다","수정해","수정해야","수준에서","수준의","수직","수퍼","수학에서의","수행됩니다.node.js가","수행됩니다.node는","수행됩니다.각","수행하고","수행하는","수행하십시오:","수행하지","수행할","수행합니다.오버로드","수행합니다.이러한","수행합니다:","수행했다고","숙련자들을","숙제","숙제로","순서","순서가","순서는","순서대로","순서로","순서를","순서의","순서표(bom)를","순위로","순차적으로","숨겨진","숫자","숫자(numeric)","숫자,","숫자/문자열","숫자나","숫자는","숫자로","숫자를","숫자여야","숫자와","숫자의","숫자인","숫자형","쉬운","쉬워","쉼표로","쉽게","쉽습니다","쉽습니다.export","쉽습니다.typescript에서","슈퍼","스스로","스위치","스칼라와","스코프","스코프가","스코프내에서","스코프는","스코프로","스코프를","스코프에","스코프에서","스코프에서는","스코프의","스코프입니다.","스크립트","스크립트가","스크립트에","스키마","스키마는","스타일","스타일과","스타일에","스타일을","스타일의","스타트","스태틱","스태틱과","스태틱을","스페이스","스페이스가","스페이스는","스페이스도","스페이스를","스페이스에서만","스페이스와","스페이스의","슬래시","슬래시는","시","시간","시간에","시간을","시간이","시그니처","시그니처(call","시그니처(constructor","시그니처(index","시그니처(special","시그니처(string","시그니처가","시그니처과","시그니처에","시그니처에는","시그니처은","시그니처을","시그니처의","시그니처이","시나리오","시나리오가","시나리오를","시나리오에","시도를","시도하게됩니다:","시도하세요:","시도할","시도합니다.","시도합니다.전체","시도합니다.파일에","시스템","시스템에","시스템에)","시스템은","시스템을","시스템의","시스템이","시스템이기","시스템입니다.두","시에는","시작","시작된","시작으로","시작점이","시작하겠습니다","시작하고","시작하기","시작하는","시작하려면","시작하면","시작하여","시작한","시작할","시작합니다.","시작합니다.각각의","시작합니다.다른","시작합니다.멤버","시작합니다.이것은","시작합시다.","시작해보겠습니다.웹","시작해봅시다.","시작해야","시작했습니다.","시점에","시점에서도","시퀀스","시험용","시험적인","식별","식별자","식별자가","식별자는","식별자로","식별자에","식별하기","식별하는","식별합니다","식별합니다,","식으로","신경","신뢰할","신중하게","신중히","신호","신호를","실수\"라고","실수가","실수는","실수로","실수를","실시하면","실제","실제로","실질적으로","실패한다면","실패합니다.","실행","실행되고","실행되는","실행되며","실행되면","실행되어야","실행되지","실행될","실행됩니다.","실행됩니다.for","실행됩니다.main.ts에서","실행됩니다.이는","실행됩니다.하지만","실행시","실행시키는","실행을","실행하게","실행하고","실행하기","실행하는","실행하도록","실행하려고","실행하며","실행하면","실행하면)","실행하십시오.","실행하여","실행하지만","실행할","실행합니다.","실행합니다.javascript에서","실행합니다:","실행해","실행해야","실험단계입니다.","실험적","실험적인","심볼","심볼과","심볼에","심볼은","심볼을","심볼의","심볼이","심지어","심플하게","싱글톤","싶다면","싶습니다.이를","싶은","싶을","싶지","쌍으로","써놓지","써드","쓰게","쓰는","쓰면","쓰이는","쓰인","쓰지","쓸","아,","아니기","아니라","아니라,els","아니라고","아니라는","아니며","아니면","아니므로","아닌","아닌)인","아닌지","아닌지에","아닐","아닙니다","아닙니다.","아닙니다.'","아닙니다.대신","아닙니다.모듈","아닙니다.블록","아닙니다.제공된","아닙니다.중요한","아닙니다.형식을","아래","아래)","아래로","아래에","아래에서","아래에서는","아래의","아래쪽에","아마","아마도","아무거나","아무런","아무렇게나","아예","아이디어는","아직","아직도","아티클의","악명","악화시키는","안","안과","안내합니다.","안내해","안다\"라고","안됩니다.","안에","안전도","안전성(type","안전성과","안전성에","안전성을","안전하게","안전한(type","안정성에서","않거나","않고","않고).j","않고는","않고도","않기","않는","않는다는","않는다면","않는지","않다고","않다는","않다면","않더라도","않도록","않습니다","않습니다(deprecated).","않습니다(명확한","않습니다)","않습니다).","않습니다.","않습니다.(역","않습니다.javascript","않습니다.preserv","않습니다.record가","않습니다.typescript는","않습니다.권장되는","않습니다.다만","않습니다.대신","않습니다.런타임에","않습니다.사용하지","않습니다.실제로","않습니다.아래","않습니다.예를","않습니다.왜냐하면","않습니다.유니온","않습니다.이","않습니다.이는","않습니다.컴파일러가","않습니다.컴파일러는","않습니다.파일의","않습니다.하지만","않습니다.현재","않습니다:","않습니다—","않아","않아도","않아야","않았기","않았다면","않았습니다","않았습니다.","않았으므로","않았을","않았지만,","않으려는","않으려면","않으며","않으면","않으므로","않으셨다면","않은","않은(non","않은)","않을","않음).즉","않지만","알","알게","알게됩니다:","알겠지만","알고","알고리즘으로","알고리즘은","알고있다는","알기","알다시피","알려","알려져야","알려주는","알려주면","알려주어야","알려줌으로써","알려줍니다.","알려줍니다.두","알려줍니다.비","알려줍니다.하지만","알려줘야","알려진","알리기","알릴","알림을","알립니다.이렇게하면","알아","알아내는","알아냈습니다.그","알아보겠습니다.","알아보기","알아야","알았으므로","알았을","알지","암시될","암시적으로","암시적인","암시한","압축되는지","압축하기","압축합니다.","앞서","앞에","앞에서","앞의","애플리케이션","애플리케이션도","애플리케이션에","애플리케이션에서","애플리케이션에서는","애플리케이션은","애플리케이션을","애플리케이션의","애플리케이션이","앨리어싱된","앰비언트","앱","앱에서","앱을","앱이","앵귤러","약간","약간의","양날의","양식에","얕은","어노테이션","어노테이션과","어노테이션은","어노테이션을","어노테이션의","어디서","어디에서","어디에서나","어딘가에","어떠한","어떤","어떻게","어려울","어려움이","어렵거나","어렵지","어색함을","어쩌면","어플리케이션에서의","어플리케이션을","억제합니다.","언급","언급됩니다.또","언급하지","언급한","언급할","언급했듯이","언급했듯이,","언급했습니다.","언급했었습니다.기본적으로","언래핑","언래핑(푸는)","언어","언어는","언어로","언어를","언어에","언어에서","언어에서는","언어에서의","언어에서처럼","언어와","언어의","언어입니다.단일","언어처럼","언제","언제나","언제든","얻고","얻습니다.생성자","얻었습니다.실제로","얻었으나","얻었을","얻을","얼마나","엄격모드(strict","엄격하게","엄격한","엄격함을","엄격합니다.열거형의","엄밀히","업그레이드하라는","업데이트","업데이트!\");","업데이트된","업데이트된다는","업데이트하세요:","업데이트하십시오","업데이트하여","업데이트할","업데이트해야","없거나","없고","없고,","없기","없기때문에(기본값을","없는","없는basiccalculator를","없는지","없다고","없다는","없다면","없습니다","없습니다!","없습니다).왜냐하면","없습니다.","없습니다..js`","없습니다.null의","없습니다.typescript에서","없습니다.그것들을","없습니다.기본","없습니다.런타임에","없습니다.사용자는","없습니다.상대적인","없습니다.어떤","없습니다.예를","없습니다.이","없습니다.이것은","없습니다.이는","없습니다.이전에","없습니다.인터페이스와","없습니다.일반적으로","없습니다.즉","없습니다.컴파일러는","없습니다.클래스","없습니다.프로퍼티는","없습니다:","없앨","없었다면","없었습니다.","없었습니다.그래서","없었습니다.여기서는","없었을","없으며","없으면","없으므로","없을","없음","없음.","없이","없지만","엉망으로","에","에는","에디터의","에러가","에러입니다.","에서","에서는","에서도","엑섹스하고,","엔진","엔진에서","엔진을","엔티티를","엔티티의","여겨집니다.","여기","여기를","여기서","여기서,","여기서는","여기서도","여기에","여기에는","여기에서","여기에서는","여러","여러개의","여러분의","여부느이","여부를","여부에","여세요!","여전히","여전히any입니다.왜냐하면","역","역매핑을","역방향(reverse)","역할을","연결(pipe)","연결되도록하여","연결될","연결됩니다.","연결의","연결하여","연결할","연결했을","연관된","연산은","연산자","연산자(index","연산자가","연산자는","연산자도","연산자로","연산자를","연산자에","연산자의","연산자입니다.어떤","열거","열거나","열거하고","열거형","열거형과","열거형까지","열거형에","열거형에서","열거형으로","열거형은","열거형을","열거형의","열거형이","열거형입니다.아래에","열고","열려있다","열면","열어","열어보세요","열어줍니다.","염두에","영향받지","영향은","영향을","옆에","예","예.","예:","예는","예로는","예를","예만","예방할","예상대로","예상되는","예상됩니다.","예상을","예상치","예상하는","예상한대로","예상할","예상합니다.즉","예술적으로","예시","예시와","예에","예에서","예에서,","예에서는","예와","예외는","예외를","예외사항은","예입니다.","예입니다.네임스페이스가","예입니다:","예정입니다.","예제","예제:","예제가","예제는","예제로","예제를","예제부터","예제에","예제에는","예제에서","예제에서,","예제에서:","예제에서는","예제와","예제와의","예제의","예제입니다.","예제입니다:","예제처럼","예측","오기","오기를","오는","오늘날에는","오래된","오류","오류!","오류).","오류,","오류.","오류:","오류가","오류는","오류라는","오류로","오류를","오류입니다.","오류입니다.파일에","오른쪽","오른쪽에","오른쪽에는","오른쪽으로","오면","오버라이드","오버라이드하고","오버라이드합니다.","오버라이딩","오버로드","오버로드가","오버로드는","오버로드로","오버로드를","오버로드만","오버로드함으로써","오버로드합니다.","오버헤드가","오역과","오염과","오직","오픈","올","올라갑니다.","올바르게","올바른","옮기면","옮깁니다.","옳다고","옵션","옵션들...","옵션으로","옵션은","옵션은commonjs,amd,system","옵션을","옵션의","와","와서","와일드","와일드카드는","와치","와치하여","완료","완료되면","완료된","완료시","완만한","완벽하게","완벽한","완성과","완성을","완전하지","완전히","왔기","왔는지에","왜","왜냐하면","외부","외부에","외부에서","외부에서는","외부의","외에는","외에도","왼쪽에","왼쪽에서","요구","요구사항이","요구하는","요구하지","요소","요소,","요소는","요소는src","요소들","요소들입니다.이","요소로","요소를","요소에","요소에서","요소와","요소의","요소이며","요소입니다.클래스는","요약하면:","요점은","요점을","요청하는","요청하면","용어가","용어는","용어로","용어에","우","우리가","우리는","우리에게","우리의","우발적인","우선","우선순위가","우선으로","우연한","우측","우회","워크플로우를","원래","원래의","원리","원본","원본과","원시","원시적인","원시적인지","원인이","원천이기","원치","원칙)","원하기","원하는","원하는대로","원한","원한다면","원할","원했지만","원활하게","웹","웹팩","위","위)와","위로","위에","위에서","위와","위의","위치","위치가","위치는","위치로","위치를","위치에","위치에서","위치에서는","위치에서만","위치의","위치하지","위치할","위키","위한","위해","위해,","위해서","위해서는","위해서는,","위해서만","위험","위험에","유니온","유니온,","유니온에","유니온으로","유니온을","유니온의","유니온이","유니온이나","유니온입니다.","유래된","유발하는","유발할","유사","유사하게","유사하지만","유사한","유사합니다.","유사합니다.이","유사합니다.트리플","유사해야","유연성은","유연성을","유연하게","유연한","유연합니다.이렇게","유용하게","유용하고","유용하기","유용하므로","유용하지","유용하지만","유용한","유용한지도","유용할","유용합니다","유용합니다.","유용합니다.fish를","유용합니다.서브","유용합니다.일부","유의한다.","유의해야","유익하고","유일한","유지","유지됩니다.","유지하거나","유지하고","유지하기","유지하는","유지하도록","유지하려면","유지하세요.","유지하지만","유지할","유지합니다.추가적으로","유지했습니다.","유추됩니다.프로퍼티","유형","유형(예:","유형에","유형을","유형의","유형화(structur","유효성","유효하지","유효한","유효합니다.이것은","유효합니다.트리플","유효현","으로","은","은닉","을","응용","의","의견","의도가","의도나","의도된","의례입니다.typescript는","의미가","의미는","의미로","의미론과","의미론을","의미론적인","의미를","의미에","의미에서","의미있고","의미하기때문에","의미하는","의미하는지","의미하므로","의미하지만","의미합니다.","의미합니다.watchify와","의미합니다.두","의미합니다.또한","의미합니다.반대로","의미합니다.이","의미합니다.일단","의미합니다.일반적으로","의미했습니다.이","의심스러울겁니다.이","의역이","의존된","의존성","의존성에","의존성으로","의존성은","의존성을","의존성이","의존하는","의존하지","의지가","의한","의해","의해서도","이","이것들은","이것들을","이것들의","이것뿐입니다.다음으로","이것은","이것을","이것이","이곳에서","이곳을","이나","이는","이니셜라이저를","이동","이동시키세요)","이동하겠습니다.이를","이동하려고","이동하세요.","이동할","이동합니다.여기서","이동했음을","이득은","이득이","이들은","이들을","이때","이라고","이라는","이러한","이런","이런,","이렇게","이렇게하면","이로","이루어지면","이를","이름","이름\"을\"","이름과","이름들의","이름뿐인","이름에","이름에서","이름으로","이름으로도","이름은","이름을","이름의","이름이","이름이어야","이름이지만","이름인","이름입니다","이름입니다.","이름입니다.여전히","이름입니다.이러한","이며","이며,","이므로","이미","이번","이번에도","이보다","이상","이상과","이상에서는","이상을","이상의","이상적으로,","이상적으로는","이상적인","이상하게","이상한","이슈","이슈를","이슈을","이야기하겠지만","이야기할","이야기합니다.때로는","이야기했습니다.인스턴스는","이어서","이어지는","이어지며","이에","이와","이용","이용한","이유","이유가","이유는","이유로","이유를","이유입니다.let은","이전","이전과","이전에","이전에는","이전의","이점을","이점이","이제","이제는","이터러블","이터레이터와","이하를","이해하기","이해하는","이해하려면","이해하면","이해할","이해함으로써","이해해야","이후","이후에","익명","익명으로","익명의","익숙","익숙하게","익숙하다면","익숙하지","익숙할","익숙해지게","익숙해지는","인","인경우","인기","인기를","인덱서(indexer)를","인덱서에서","인덱서의","인덱스","인덱스를","인덱스에","인덱스에서","인덱스을","인덱스의","인덱싱","인덱싱을","인덱싱하기","인덱싱하는","인덱싱하면","인라인","인라인(inline)되지","인라인(inline)됩니다.const","인쇄할","인쇄해야합니다.","인수","인수,","인수가","인수는","인수들을","인수로","인수를","인수에","인수에는","인수와","인수의","인스턴스","인스턴스가","인스턴스는","인스턴스들을","인스턴스를","인스턴스에도","인스턴스에서","인스턴스의","인스턴스화될","인스턴스화하고","인스턴스화하므로","인스턴스화할","인식됩니다.","인식됩니다.비슷하게,","인식됩니다:","인식하기","인식하는","인식하는지","인식하지","인터셉트하는","인터페이스","인터페이스,","인터페이스가","인터페이스나","인터페이스는","인터페이스도","인터페이스로","인터페이스를","인터페이스보다","인터페이스에","인터페이스에서","인터페이스와","인터페이스의","인터페이스처럼","인해","일","일관된","일관성이","일단","일대일","일련의","일반","일반적으로","일반적이라고","일반적이라는","일반적이며","일반적이지","일반적인","일반적일","일반적입니다.매개","일부","일부(개발자에게)","일부가","일부는","일부로","일부로만","일부로써","일부를","일부만","일부이며","일부인","일부임에도","일시","일어나는지","일어날까요?javascript에서","일에","일으킬","일은","일을","일이","일이기","일입니다.더","일정한","일종의","일치","일치하고","일치하는","일치하는지만","일치하다면","일치하도록","일치하지","일치할","일치합니다","일치해야","일치해야합니다.이렇게하면","일회성","읽거나","읽기","읽습니다","읽습니다.","읽어","읽어보세요.","읽어보세요.yehuda의","읽어볼","읽어야","읽어야하는","읽어야합니다.","읽었고","읽은","읽을","읽지","잃어","잃어버리지","잃어버린다는","잃어버립니다.만약","잃지","임의","임의로","임의의","임포트","임포트와","임포트입니다.몇","임포트하는","임포트합니다.","입니다","입니다.","입니다.awesom","입니다.c#와","입니다.extends'","입니다.jsx.elementattributesproperty를","입니다.즉","입니다:","입력","입력과","입력에","입력으로","입력을","입력하고","입력하면","입력하세요:","입력하십시오","입력할","입력합니다.","입증하기","있게","있게되지만","있게합니다.","있고","있기","있기는","있기를","있는","있는)","있는지","있는지는","있는지를","있는지에","있다\";","있다.","있다고","있다는","있다면","있던","있도록","있듯이","있면","있습니다","있습니다!","있습니다\"","있습니다(병합되지","있습니다(한","있습니다).","있습니다.","있습니다.\"compileonsave\"는","있습니다.\"하세요\"와","있습니다.(javascript에","있습니다.(스크립트는","있습니다.)","있습니다.:","있습니다.abstract","있습니다.ani","있습니다.a의","있습니다.c/c++에","있습니다.const","있습니다.const는","있습니다.createsquare에","있습니다.decor","있습니다.default","있습니다.discrimin","있습니다.doanimalshavemuscl","있습니다.ecmascript6로도","있습니다.javascript","있습니다.javascript에서는","있습니다.kind","있습니다.loggingident","있습니다.microsoft","있습니다.node는","있습니다.observ","있습니다.printlabel에","있습니다.react","있습니다.state는","있습니다.string","있습니다.typeof","있습니다.typescript","있습니다.typescript는","있습니다.typescript도","있습니다.typescript를","있습니다.typescript에서는","있습니다.typescript의","있습니다.v","있습니다.var","있습니다.visual","있습니다.►","있습니다.가능하면","있습니다.각각의","있습니다.결과적으로","있습니다.경우에","있습니다.구문은","있습니다.그들이","있습니다.그러나","있습니다.그런","있습니다.그럼에도","있습니다.그렇게","있습니다.그렇기","있습니다.기본","있습니다.기호를","있습니다.나중에는","있습니다.내보낼","있습니다.내장","있습니다.네임스페이스는","있습니다.다소","있습니다.다시","있습니다.다음","있습니다.다음과","있습니다.다음은","있습니다.단어의","있습니다.단편적으로","있습니다.데코레이터는","있습니다.두","있습니다.따라서","있습니다.또한","있습니다.마찬가지로","있습니다.만약","있습니다.먼저","있습니다.메서드","있습니다.명시적","있습니다.몇","있습니다.모듈은","있습니다.모듈이","있습니다.목록","있습니다.문","있습니다.문자","있습니다.물론","있습니다.반대로","있습니다.변수","있습니다.브라우저의","있습니다.비슷한","있습니다.사용자를","있습니다.실제로","있습니다.아래","있습니다.아마도","있습니다.앞","있습니다.어떠한","있습니다.어떤","있습니다.여기서","있습니다.여기서는","있습니다.여기에서","있습니다.열거형","있습니다.열거형의","있습니다.예를","있습니다.왜냐하면","있습니다.외부의","있습니다.원본","있습니다.이","있습니다.이것은","있습니다.이것을","있습니다.이것이","있습니다.이러한","있습니다.이런","있습니다.이렇게","있습니다.이렇게하면","있습니다.이를","있습니다.이전","있습니다.이제","있습니다.인덱싱","있습니다.일반적으로","있습니다.자세한","있습니다.전형적으로","있습니다.접근제어자","있습니다.제네릭","있습니다.즉","있습니다.즉,","있습니다.지정하지","있습니다.첫번째","있습니다.최선을","있습니다.컴파일러는","있습니다.클래스","있습니다.타입","있습니다.파일","있습니다.페이지를","있습니다.프로퍼티를","있습니다.하지만","있습니다.한","있습니다:","있습니다:하나는","있어","있어도","있어서는","있어야","있어야합니다.마찬가지로","있었는데","있었던","있었습니다.","있었습니다.이","있었습니다:","있었음에도","있으며","있으며(이","있으며이를","있으면","있으므로","있을","있음)에","있음)을","있음을","있지","있지만","잊어버렸을","잊어버리면","자기","자동","자동으로","자동적으로","자료는","자리에","자바스크립트를","자세한","자세히","자식들만이","자식만","자신만의","자신을","자신의","자연스럽게","자연스럽습니다.","자유롭게","자주","자체","자체가","자체는","자체로","자체를","자체에","자체에는","자체와","자체의","자체적으로","자체적인","작고","작동","작동하는","작동하는지","작동하는지를","작동하는지에","작동하도록","작동하려면","작동하며","작동하여","작동하지","작동하지만","작동한다는","작동할","작동합니다","작동합니다.","작동합니다.greeter","작동합니다.typescript에서","작동합니다.간단한","작동합니다.매핑된","작동합니다.이를","작동합니다:","작성","작성되는","작성되며","작성되었습니다.","작성되지","작성된","작성될","작성됩니다.","작성에","작성의","작성자는","작성하게","작성하고","작성하기","작성하기에","작성하는","작성하든","작성하세요.","작성하여","작성한","작성할","작성합니다.","작성합니다.마지막으로,","작성합니다:","작성해","작성해보겠습니다.","작성해보겠습니다.다음과","작성해보세요","작성해야","작성했다고","작성했다면:","작성했습니다.","작성했으므로","작성했을","작업","작업에는","작업에서","작업은","작업을","작업하고","작업하기","작업하는","작업할","작업할수","작업해야","작용하고","작용할","작용합니다.","작용합니다.문자열","작용합니다.중요한","작은","잘","잘못","잘못된","잠깐","잡기","잡는","잡아내지","잡을","장기적","장기적인","장소로","장애와","장에서","장에서는","장의","장점은","재","재구성하지는","재귀적으로","재빠르게","재사용","재사용,","재사용하기","재선언과","재정의됩니다.순환성","재정의하는","재할당","저장","저장된","저장소입니다.","저장하는","저장하십시오.","저장한","저장할","적는","적다는","적어도","적어도x와","적어야","적용","적용되고","적용되기","적용되는","적용되며","적용되어야","적용되지","적용된","적용된다.","적용됩니다.","적용됩니다.매개변수","적용됩니다.이를","적용됩니다.일반적인","적용됩니다.클래스","적용하는","적용하면","적용할","적은","적이","적재할","적절하게","적절한","적합하도록","적합한","전개","전개는","전개로","전개를","전개보다","전개에","전개하는","전개한","전개할","전달","전달되는","전달되었습니다.","전달되지","전달된","전달된대로","전달하고","전달하고자","전달하는","전달하더라도","전달하면","전달하여","전달하지는","전달할","전달해야","전달했는지","전달했는지에","전략","전략에는","전략은","전략을","전략이","전략이었습니다.요즘은","전문","전문적이거나","전방향(forward)","전송되는","전에","전에는","전역","전역으로","전용","전용(readonly)으로","전용으로","전용이므로","전용인","전제로","전제로합니다.","전처리","전처리됩니다.파일이","전체","전체에서","전통적으로","전통적인","전혀","전형적으로","전환하기","절대","절대로","절대적인","절에","절충","점","점에","점에서","점은","점은,","점을","점이","점이다.그리고","점입니다.","점입니다:","점진적으로","점차적으로","점프합니다.이것은","접근","접근법은","접근으로","접근은","접근을","접근이","접근자","접근자가","접근자는","접근자를","접근자에","접근제어자","접근제어자,","접근제어자를","접근제어자에","접근제어자에게","접근하기","접근하기를","접근하는","접근하여","접근할","접근합니다.인스턴스의","접두사","접두사는","접두어","접두어로","접미사를","접해봤다면","접했을","정교한","정규","정규식","정규식과","정당한","정도로","정렬되어","정렬하는","정렬합니다.각","정리하도록","정말","정말로","정반대이지만","정보","정보가","정보는","정보도","정보를","정보와","정의","정의가","정의되기","정의되면","정의되어","정의되지","정의된","정의될","정의됩니다.","정의됩니다.반환","정의로","정의를","정의에","정의에는","정의인","정의하고","정의하기","정의하기만","정의하는","정의하려면","정의하여","정의하지","정의한","정의할","정의합니다.","정의합니다.typescript","정의합니다.그러나","정의합니다.이","정의합니다.편의상","정의해야","정적","정적인","정하는","정해진","정했으며","정확하게","정확하게는","정확한","정확히","제거되었습니다.case를","제거된","제거됩니다.const","제거하고","제거하는","제거하면","제거할","제거합니다.","제거합니다:","제거해보세요.typescript는","제거해야","제공\"할","제공되는","제공되지","제공되지만","제공된","제공될","제공하게","제공하고","제공하기","제공하는","제공하려면","제공하며","제공하지","제공한","제공할","제공합니다","제공합니다\".또는","제공합니다\".이","제공합니다.","제공합니다.map","제공합니다.데코레이터는","제공합니다.반면","제공합니다.원래","제공합니다.이것은","제공합니다.일단","제공해야","제공해야합니다:","제공했는지","제네레이터","제네릭","제네릭에서","제네릭으로","제네릭을","제네릭의","제네릭이","제네릭이므로","제네릭인지","제대로","제안","제안될","제안이며","제약","제약으로서","제약조건","제약조건에서","제약조건을","제어하기","제어할","제외","제외)","제외).특히","제외되는","제외되었는지","제외된","제외될","제외됩니다.","제외됩니다.선택사항을","제외됩니다.일반적으로","제외하고","제외하고).ani","제외하고는","제외하려면","제외한","제외합니다.","제외합니다.allowjs가","제외해야","제한","제한되는","제한되어","제한되어있고","제한되어있습니다.","제한되지","제한된","제한을","제한이","제한하는","제한하도록","제한할","제한합니다.","조각은","조건","조건부","조건에서만","조건을","조금","조심히","조용히","조작할","조절할","조직","조직으로","조차도","조치를","조합","조합으로","조회됩니다.","조회를","조회할","존재","존재를","존재하거나","존재하기를","존재하는","존재하지","존재한다고","존재한다는","존재할","존재합니다.","존재합니다.javascript","존재합니다.경로와","존재합니다.이러한","좀","좁혀","좁혀지더라도","좁히는","종료된","종류가","종류에","종류와","종류의","종류인","종류일뿐입니다:","종속성을","종종","좋겠습니다.예를","좋습니다","좋습니다.","좋습니다.(아래의","좋습니다.페이스북은","좋아요","좋아요,","좋아요.","좋아요:","좋았어!javascript에서","좋은","좋지만","좌절의","주고","주기","주는","주듯이","주로","주로하는","주며","주목됩니다.","주목하는","주목하세요","주목하세요.","주목하세요.일단","주목하십시오.javascript는","주목하십시오.react와","주목하십시오.typescript를","주목하십시오.이로","주목할","주목할만한","주문이","주석","주석으로","주석은","주석을","주석이","주석입니다.주석의","주어야","주어지면","주어진","주어질","주어집니다.가장","주요","주의:","주의사항","주의사항,","주의사항:","주의사항이","주의하십시오.\"baseurl\"을","주의해야","주의해야합니다.","주입되는","주입합니다.","주입해야하는","주장하고","주장할","주제","주제를","주제입니다.","주지","주지만","준다.","준비가","준비됐나요?","줄","줄에","줄에:","줄에서","줄에서는","줄은","줄을","줄이","줄이는","줄이도록","줄이지","줄일","줄임말입니다.","줄임표","줄임표(...)는","줌으로써","줍니다.","줍니다.클래스의","중","중간","중괄호","중에","중에서","중요하다는","중요하지","중요한","중요합니다.","중요합니다.그렇지","중요합니다.예를","중요합니다.이","중요합니다.전통적으로,","중이며","중인","중입니다!","중지","중지(opt","중지하고","중지합니다.","중지했을","중첩","중첩된","중첩의","즉","즉,","즉시","즐겁다는","즐겨","증가","증가하고","증가하지","증가함에","증가합니다.즉,","증명할","지","지금","지금까지","지금까지는","지금부터","지금은","지나면","지나치기도","지루하지만","지시자","지시자가","지시자는","지시자도","지시자로","지시자를","지시자와","지시자입니다.파일","지시하고","지시합니다.","지시합니다.또한","지시합니다.모듈을","지시합니다.여기에","지식과","지식을","지식이","지역","지역변수","지역변수로","지역에","지역화,","지우지","지원","지원:","지원되는","지원되지","지원됩니다.","지원에서","지원은","지원을","지원이","지원하기","지원하는","지원하며","지원하지","지원할","지원합니다.","지원합니다.default","지원합니다.다음은","지원합니다.여기서","지원합니다.이것을","지원해야","지을","지적하는","지점에서","지정","지정)","지정:","지정되면","지정되므로","지정되어","지정되었다는","지정되지","지정된","지정됩니다.","지정됩니다:","지정에","지정자","지정자(access","지정자는","지정자를","지정자와","지정하고","지정하기","지정하기를","지정하는","지정하려고","지정하려는","지정하려면","지정하면","지정하세요","지정하세요.","지정하여","지정하지","지정한","지정한다는","지정할","지정합니다","지정합니다.","지정합니다.따라서","지정합니다.이","지정합니다:","지정해야","지정해야합니다.","지정했지만","지향","직감을","직감적이고","직관이","직관적인","직면하게","직전에","직접","직접적으로","직접적인","진단","진단하거나","진행","진행되고","진행되어","진행됩니다.","진행하지만","진행할","질문","질문들과","질문은","집니다.","집합","집합에","집합에서","집합으로","집합을","집합이","집합이기","집합인것처럼","집합입니다","집합입니다.표현식은","짧고","짧은","찍을","차례대로","차별된","차별화된","차용해보겠습니다:","차이","차이가","차이를","차이에","차이점","차이점(differ","차이점에","차이점은","차이점을","차이점이","차이점입니다:","참고","참고:","참고로","참고하여","참고하였으며","참조","참조).","참조가","참조는","참조되는","참조됩니다.","참조를","참조에","참조에서","참조이므로","참조하고","참조하기","참조하는","참조하는지","참조하며","참조하세요.","참조하세요.네임스페이스에","참조하세요.이","참조하세요.확대되는","참조하십시오.","참조할","참조합니다","참조합니다.","참조해야","창에서","찾게","찾고","찾기","찾기와","찾는","찾습니다.","찾습니다.나중에는","찾습니다.따라서","찾습니다.이","찾습니다.이렇게하기","찾아","찾아내는","찾아냈기","찾아보게","찾아야","찾으려","찾으려고","찾으려합니다.","찾으면","찾은","찾을","찾지","채우게","채우기","채우기만","채워진","채택되도록","채택되면","챕터에서","챘을","처럼","처리되고","처리된","처리될","처리됩니다)","처리됩니다.","처리됩니다.rest","처리를","처리하고자","처리하는","처리하므로","처리한다고","처리할","처리합니다.","처음","처음의","철자가","철저한","철저히","첨부될","첫","첫번째","첫번째,","첫번째는","첫째,","체계가","체계를","체인에서","체인으로","체인을","체커가","체커는","체커에서","체커에서는","체크","체크!","체크가","체크하지","체킹을","초","초과","초기의","초기화","초기화가","초기화되는","초기화되지","초기화된","초기화될","초기화됩니다.마찬가지로","초기화됩니다.상수","초기화로","초기화를","초기화만","초기화하거나","초기화하고","초기화할","초기화합니다.","초기화해야합니다.","초보","초보자를","초점을","최대","최상위","최선을","최선의","최소한","최신","최적의","최적이","최적화가","최적화되고","최종","추가","추가되기","추가되는","추가되었습니다:","추가된","추가됩니다.","추가적으로","추가적인","추가하거나","추가하겠습니다:","추가하고","추가하고자","추가하기","추가하는","추가하면","추가하세요.","추가하세요:","추가하십시오","추가하십시오.","추가하십시오.그런","추가하여","추가하지","추가할","추가함에","추가합니다","추가합니다.","추가합니다.@valid","추가합니다.default가","추가합니다.getformat를","추가합니다.npm과","추가합니다.생성된","추가합니다.이는","추가합니다.테스트","추가합니다.표현이나","추가합니다:","추가해","추가해보겠습니다.","추가해야","추가했습니다.","추가했습니다.이","추론","추론(type","추론되기를","추론되는","추론되는지","추론된","추론된)","추론됩니다.마지막","추론됩니다.이것은","추론됩니다.이러한","추론은","추론의","추론이","추론하고","추론하기","추론하지","추론할","추론했습니다.이렇게","추상","추상적이지","추상화","추상화된","추상화를","추상화할","추적","추적을","추적하고","추적할","추측을","출력","출력과","출력된","출력됩니다.","출력에","출력에는","출력에서는","출력은","출력을","출력의","출력이","출력하도록","출력합니다!","출력합니다.","출력합니다:","출발점이지만","충돌된","충돌에","충돌으로","충돌은","충돌을","충분한","충족시키기","충족시킵니다.비록","충족하는","충족하도록","취급되어","취급힙니다.","취소합니다.","취하고","취하는","취하지","취할","취합니다,","취합니다.pickcard를","측면","측면과","측면만","측면에서","측면에서는","측면에서만","측면의","측면이","측면이기","측에","측에서","친숙하지만","친숙한","카드가","카드를","캐시","캡처된","캡처하여","캡처하지","캡처할","캡처합니다.","캡처합니다:","캡쳐","캡쳐된","캡쳐를","캡쳐링에","캡쳐링의","캡쳐하기","캡쳐하는","캡쳐한","캡쳐할","캡쳐합니다","캡쳐했으므로","커맨드","커맨드라인에서","커멘드","커뮤니티에서도","커서를","커스터마이징하고","커스텀","컨벤션을","컨텍스트","컨텍스트(예:","컨텍스트를","컨텍스트에서","컨텐츠가","컨텐츠를","컨텐츠에서","컬렉션","컴파일","컴파일(기본값)을","컴파일된","컴파일됩니다.다른","컴파일됩니다:","컴파일러","컴파일러가","컴파일러는","컴파일러를","컴파일러에","컴파일러에게","컴파일러에는","컴파일러에서","컴파일러에서만","컴파일러의","컴파일러입니다.따라서","컴파일시","컴파일에","컴파일에서","컴파일을","컴파일의","컴파일하기","컴파일하는","컴파일하려면","컴파일하면","컴파일하면,","컴파일하세요.이","컴파일할","컴파일합니다.","컴파일합니다.이를","컴포넌트","컴포넌트(stateless","컴포넌트는","컴포넌트로","컴포넌트를","컴포넌트의","컴퓨터에","케이스에","켜고","코드","코드:","코드가","코드는","코드로","코드를","코드에","코드에는","코드에서","코드에서,","코드에서는","코드와","코드의","코드입니다.generated/templ","코드입니다.빌드","코드처럼","코딩되어","코딩된","코어","콘솔에","콜론은","콜백","콜백에서","콜백에서의","콜백을","쿼리","쿼리와","쿼트","퀵","크게","크지만","큰","클래스","클래스(subclasses)","클래스(superclasses)","클래스)에서","클래스,","클래스가","클래스나","클래스는","클래스들의","클래스라면","클래스로","클래스를","클래스뿐만","클래스에","클래스에는","클래스에서","클래스에서는","클래스에서만","클래스와","클래스의","클래스인","클래스입니다.네임스페이스를","클래스입니다.또한","클래스입니다.추상","클래스입니다.파생","클래스처럼","클래식","클래식.","클래식이며","클릭","클릭하고","클릭하십시오.","클릭하십시오.'default'","클릭하십시오.그런","클릭합니다.그런","키","키로","키를","키워드","키워드가","키워드는","키워드로","키워드를","키워드와","키의","타겟으로","타겟이","타이프","타이핑(contextu","타이핑(duck","타이핑과","타이핑은","타이핑이니까","타임","타임에","타임에는","타입","타입\"과","타입\"에","타입\"을","타입(contextu","타입(index","타입(상위","타입(예","타입(예:","타입)을","타입)이","타입,","타입.","타입.전체","타입construct","타입과","타입도","타입들에","타입들은","타입라는","타입를","타입만","타입변수","타입보다","타입뿐만","타입스크립트","타입에","타입에는","타입에도","타입에만","타입에서","타입에서만","타입으로","타입으로도","타입은","타입을","타입의","타입이","타입이거나","타입이기","타입이되도록","타입이든","타입이라고","타입이며","타입이므로","타입이어야","타입이어야합니다","타입인","타입인지","타입임을","타입입니다","타입입니다(왜냐하면","타입입니다.","타입입니다.매개변수와","타입입니다.즉","타입처럼","탐색기를","탐색합니다.","태그","태그가","태그는","태그로","태그를","태그와","태스크를","태스크에","탭을","테스트","테스트입니다.","테스트입니다.새로운","테스트입니다:","테스트하는","테스트하십시오.페이지에","테스트하여","테스트할","텍스트","텍스트를","텍스트의","템플릿","템플릿에서","템플릿이","템플릿입니다.왜냐하면","토니","토큰","통과","통과되지만","통과하는","통과하도록","통과할","통과해서는","통과했는지","통찰력을","통합","통합됩니다.거기서","통합은","통합이","통합했습니다.","통해","통해)","튜토리얼에서","튜토리얼에서는","튜토리얼이","튜플","트랜스파일러를","트렌드는","트리를","트리플","특별하게","특별한","특별합니다.즉","특성에","특성으로","특성을","특성이","특성입니다.","특수","특수한","특수화된","특정","특정한","특징은","특화된","특히","틀리거나","팀원들과","파는","파라미터","파라미터를","파생","파생되기","파생된","파생될","파싱에는","파싱을","파싱합니다.","파악하기","파악할","파이프","파일","파일(*.d.ts)의","파일(.js와","파일(declar","파일(lib.d.ts)은","파일,","파일:","파일과","파일도","파일들","파일들:","파일들로","파일들에","파일들은","파일들을","파일로","파일만","파일별","파일뿐만","파일에","파일에는","파일에서","파일에서와","파일은","파일을","파일의","파일이","파일이나","파일입니다)","파일처럼","파트가","파트는","파트로","파티","판결났다면","판단되는","판단을","판단하는","패치","패키지","패키지가","패키지는","패키지로","패키지를","패키지만","패키지에","패키지에는","패키지에서","패키지의","패턴","패턴\"이라고","패턴과","패턴은","패턴을","패턴의","패턴이","패턴입니다.","패턴입니다:","팩토리","팩토리를","팩토리에","팩토리입니다","팩토리입니다.@enumerable(false)","팩토리입니다.@format(\"hello,","페이지","페이지가","페이지를","페이지에","페이지와","페이지의","편리하지만","편리한","편리합니다.","편리합니다.그렇게하기","편리합니다.예를","편입니다.","편집","편집기","편집기로","편집기에서","편집하는","평가","평가는","평가되는","평가되어야","평가될","평가됩니다.","평가할","평범한","포","포맷과","포맷에","포맷으로","포맷은","포맷이","포함","포함)","포함,","포함되는","포함되며","포함되면","포함되어","포함되지","포함된","포함될","포함됩니다","포함됩니다.","포함됩니다.\"exclude\"","포함됩니다.greetermaker에","포함됩니다.각각의","포함됩니다.기본적으로","포함됩니다.동봉된","포함됩니다.일부","포함됩니다.최종적으로","포함됩니다.트리플","포함시키기","포함시킬","포함시킵니다.\"exclude\"","포함시킵니다.가장","포함이","포함입니다.위에서","포함하고","포함하고있는","포함하기","포함하는","포함하도록","포함하면","포함하여","포함하지","포함한","포함할","포함합니다.","포함합니다.\"outdir\"","포함합니다.node_modules/@types/*","포함합니다.typescript를","포함해야","폴더","폴더가","폴더는","폴더로","폴더를","폴더에","폴더에서","폴더의","폴더입니다.","표기법을","표시되고","표시되는","표시되면","표시되어야","표시되지","표시되지만","표시된","표시될","표시됩니다","표시됩니다.","표시됩니다.built에","표시됩니다:","표시하는","표시하도록","표시할","표시합니다","표시합니다.","표시합니다.이","표준","표준에","표준의","표현식","표현식,","표현식과","표현식만","표현식에","표현식에서","표현식으로","표현식은","표현식을","표현식의","표현식이","표현식이거나","표현식이나","표현식인","표현식입니다.변수는","표현식입니다.타입","표현식입니다:","표현하는","표현할","품질","품질의","풍부한","프로그래머가","프로그래밍","프로그래밍과","프로그래밍에","프로그래밍에서","프로그램에서","프로그램에서부터","프로그램을","프로그램의","프로그램이","프로세스","프로세스는","프로세스를","프로세스에","프로세스에서","프로세스와","프로세스입니다.import","프로젝트","프로젝트가","프로젝트는","프로젝트를","프로젝트에","프로젝트에서","프로젝트의","프로토","프로토타입","프로토타입을","프로토타입의","프로토타입이","프로퍼티","프로퍼티(paramet","프로퍼티가","프로퍼티과","프로퍼티는","프로퍼티도","프로퍼티들은","프로퍼티들을","프로퍼티들의","프로퍼티로","프로퍼티로서","프로퍼티를","프로퍼티뿐만","프로퍼티에","프로퍼티에는","프로퍼티에만","프로퍼티에서","프로퍼티와","프로퍼티을","프로퍼티의","프로퍼티인","프로퍼티인지","프로퍼티입니다.","플래그를","플랫폼)","플랫폼에서","플러그인","플러그인과","플러그인으로","플러그인을","플러그인이","플러그인입니다.","플러그인입니다.vinyl","플레이그라운드로","피드백은","피하고자","피하는","피하려면","피할","피해야","필드가","필드를","필드에","필드인","필수","필수로","필수적으로","필수적인","필요가","필요는","필요도","필요로","필요없는","필요에","필요하다고","필요하다는","필요하지","필요한","필요할","필요할때도","필요합니다)","필요합니다.","필요합니다.babel은","필요합니다.기본적으로","필요합니다.다음과","필요합니다.또한","필요합니다.매개변수","필요합니다.여기서는","필요했었습니다.때문에","필터링할","하게","하겠습니다","하고","하고자","하기","하나","하나가","하나는","하나도","하나라도","하나로","하나로서","하나를","하나만","하나씩","하나에서","하나와","하나의","하나인","하나일","하나입니다.","하는","하도록","하드","하듯이","하려면","하며","하면","하므로","하세요!","하세요.","하세요:","하십시오.","하에","하여","하위","하위의","하이브리드","하지","하지만","한","한,","한가지","한계가","한곳에서","한글","한다는","한다면","한번","한정되는","한쪽에","한쪽에는","한편으로는,","할","할당","할당과","할당되는","할당되어야","할당되지","할당될","할당됩니다.","할당에서","할당은","할당을","할당의","할당이","할당입니다.","할당하거나","할당하는","할당하려고","할당하여","할당할","할당합니다.","할당합니다.예를","할당합니다.이것은","할수","할지","할지도","함께","함께)","함수","함수,","함수가","함수거나","함수나","함수는","함수도","함수라고","함수라는","함수라면","함수로","함수를","함수만","함수에","함수에는","함수에서","함수와","함수을","함수의","함수이기","함수이든","함수입니다.","함수입니다.예제를","함수입니다.이는","함수처럼","함수클래스는","함수형","함을","함정을","합니다","합니다(즉","합니다.","합니다.(3)을","합니다.(실행이","합니다.button과","합니다.c에서","합니다.javascript에서","합니다.jsx","합니다.jsx는","합니다.last","합니다.node.js는","합니다.npm","합니다.padleft의","합니다.script","합니다.this.suits[pickedsuit]에서","합니다.tsconfig는","합니다.typescript","합니다.webpack을","합니다.결과","합니다.고유하지","합니다.그것들은","합니다.그러나","합니다.그런","합니다.그렇게","합니다.그렇지","합니다.너무","합니다.다른","합니다.다행히","합니다.다행히도","합니다.대부분의","합니다.따라서","합니다.또한","합니다.런타임시","합니다.루프","합니다.메서드와","합니다.배열의","합니다.상황적","합니다.새로운","합니다.세가지","합니다.실수로","합니다.아직","합니다.앞서","합니다.여기","합니다.여기서","합니다.여기서는","합니다.예를","합니다.왜냐하면","합니다.유효한","합니다.이","합니다.이것은","합니다.이러한","합니다.이렇게","합니다.이를","합니다.이에","합니다.이외에","합니다.이제","합니다.일반적인","합니다.즉","합니다.최종","합니다.추상","합니다.출력","합니다.컴파일러는","합니다.프로세스가","합니다.프로젝트","합니다.프로젝트를","합니다.프로퍼티","합니다.하지만","합니다.향후에는","합니다:","합법적","합성","합집합(union)","합집합을","항목에","항목에서","항목으로","항목을","항목이","항상","해","해결","해결책은","해결하기","해결하는","해결하려고","해결하려면","해결하지","해결할","해결합니다.만약","해결해야","해당","해당되는","해당하는","해보세요","해보세요...","해석","해석되었습니다.","해석되었으며","해석되지","해석된","해석된다는","해석될","해석됩니다.","해석됩니다.그러므로","해석됩니다.자세한","해석은","해석을","해석의","해석이","해석하기","해석하기위해","해석하는","해석하려고","해석하지","해석할","해석합니다.","해석합니다:","해야","해야할까요?","해제할","해주는","해주시면","해줍니다.","해줍니다.이것은","해체","해체할","해치지","핵심","핸드북을","핸드북의","핸들러","핸들러의","핸들링하지","했기","했다는","했던","했습니다!","했습니다.","했습니다.따라서","했습니다.이를","했으므로","했을","했음에도","향상된","향후","허용되는","허용되며","허용되지","허용된","허용됨","허용됨,","허용됩니다.","허용됩니다.exports와","허용하는","허용하는지","허용하십시오.","허용하지","허용하지만","허용할","허용합니다","허용합니다.","허용합니다:","허용해준다는","헤더","헬퍼","헬퍼를","현대적인","현재","현재의","형","형성하기","형성하려면","형성할","형성합니다.","형식","형식에","형식으로","형식으로도","형식을","형식이","형식입니다.","형의","형태","형태가","형태로","형태를","형태을","형태의","형태일","혜택","호부와","호스팅","호스팅하는","호어는","호출","호출과","호출되는","호출되는지","호출되더라도","호출되며","호출되면","호출되어야한다는","호출된","호출될","호출됩니다.","호출됩니다.이는","호출됩니다:","호출들은","호출로","호출만","호출에","호출에서","호출은","호출을","호출이","호출하거나","호출하고","호출하기","호출하는","호출하도록","호출하려고","호출하면","호출하여","호출한","호출할","호출함으로써","호출합니다.","호출합니다.일반적으로","호출해야","호출해야한다는","호출해야합니다.","호출했다는","호환","호환가능한","호환되고","호환되는","호환되며","호환되면","호환되지","호환된다는","호환됩니다.그러나","호환됩니다.다른","호환됩니다.이것은","호환됩니다.차이점은","호환성","호환성(compatible)이","호환성에","호환성은","호환성을","호환성이","혹시","혹은","혼동되어서는","혼동을","혼란스러움","혼란스러워지기","혼란스럽겠지만","혼란스럽고","혼란스럽습니다.","혼란스럽습니다.이름","혼자가","혼재되어","혼합될","홈페이지의","화살표","화살표(=>)를","확대","확대는","확대를","확대에서","확대와","확보할","확실하지","확실한","확실할","확실히","확인","확인되므로","확인하거나","확인하고","확인하기","확인하는","확인하세요.","확인하세요.greeter","확인하세요.msbuild","확인하십시오","확인한다는","확인할","확인합니다","확인합니다.","확인합니다.printlabel","확인합니다.이","확인합니다.이를","확인합니다:","확인해보세요","확인해보세요.","확인해야","확장","확장/구현할","확장된","확장될","확장시키기","확장에","확장에서만","확장을","확장이","확장입니다.","확장자","확장자가","확장자로","확장자를","확장자만","확장하거나","확장하고","확장하는","확장하면","확장하여","확장하지도","확장할","확장합니다.","확장해","확장해야","환경","환경내에서","환경에","환경을","환경의","환영합니다:)","활동이나","활성화가","활성화되면","활성화하려면","활성화하면","활성화하세요","활성화하여","활성화합니다.","활성화해야","활용되어","활용하여","활용하여보다","활용할","회상해봅시다.","회피하고","획득하지","횟수가","효과는","효과에","효과적으로","효과적입니다.때문에","후","후보","후에","후에는","후에도","후위","후위에","후위의","후행","훌륭한","훨씬","흐름을","흔치","흔한","흔히","흥미로운","흭득하였습니다.","힘든","힘들기","힘이"],"pipeline":["stopWordFilter","stemmer"]},"store":{"./":{"url":"./","title":"소개","keywords":"","body":"TypeScript-Handbook 한글 문서\n\nTypeScript Handbook을 번역하는 저장소입니다.\n번역 품질\n초보 번역가이며 기초적인 Java 지식과 JavaScript 개발을 주로하는 개발자들이 함께 번역했습니다.TypeScript 번역을 하며 전문적이거나 의미론적인 지식이 많이 필요했었습니다.때문에 오역과 의역이 있을 수 있습니다.단어의 선정이나 규칙은 구글 검색량과 IT 전문 사전을 대체로 참고하였으며 모던하게 주로 쓰이는 단어를 우선 순위로 두었습니다.\n번역 범위\nTypeScript Handbook의 모든 페이지를 번역할 예정입니다.\n향후 MS측의 TypeScript 공식 번역이 지원되지 않는다면 TypeScript 홈페이지의 모든 부분과 릴리즈 버전에 대한 번역도 할 의지가 있습니다.\n진행 상황\n이곳을 통해 확인할 수 있습니다.\n기여\n번역가이드 및 규칙을 참고하여 develop 브랜치에 PR 해주시면 됩니다.\n깃헙 사용이 어렵거나 간단한 의견 같은 경우에는 이슈 등록을 해주시면 감사하겠습니다\n그 밖에도 다양한 의견 및 피드백은 언제나 환영합니다:)\n"},"pages/tutorials/TypeScript in 5 minutes.html":{"url":"pages/tutorials/TypeScript in 5 minutes.html","title":"5분 안에 보는 TypeScript","keywords":"","body":"TypeScript로 간단한 웹 애플리케이션 만들기를 시작해봅시다.\nTypeScript 설치하기 (Installing TypeScript)\nTypeScript를 설치하는 방법은 크게 두가지입니다:\n\nNPM을 통해 설치 (Node.js 패키지 매니저)\nTypeScript의 Visual Studio 플러그인 설치\n\nVisual Studio 2017 및 Visual Studio 2015 Update 3에는 기본적으로 TypeScript가 포함되어 있습니다.Visual Studio와 함께 TypeScript를 설치하지 않았다면 다운로드할 수 있습니다.\nNPM 사용자의 경우:\n> npm install -g typescript\n\n첫번째 TypeScript 파일 만들기 (Building your first TypeScript file)\n편집기에서 greeter.ts파일을 만들고 다음 JavaScript 코드를 입력하세요:\nfunction greeter(person) {\n    return \"Hello, \" + person;\n}\n\nlet user = \"Jane User\";\n\ndocument.body.innerHTML = greeter(user);\n\n코드 컴파일하기 (Compiling your code)\n.ts 확장자를 사용했지만 이 코드는 단지 JavaScript입니다.\n기존 JavaScript 앱에서 바로 복사 / 붙여넣기 할 수 있습니다.\n명령줄에서 TypeScript 컴파일러를 실행합니다:\ntsc greeter.ts\n\n결과는 동일한 자바스크립트를 포함하고있는 greeter.js 파일이 될 것입니다.JavaScript 애플리케이션에서 TypeScript를 실행 중입니다!\n이제 TypeScript가 제공하는 새로운 기능들을 활용할 수 있습니다.다음과 같이 'person' 함수의 인수에 : string 타입 어노테이션을 추가하세요:\nfunction greeter(person: string) {\n    return \"Hello, \" + person;\n}\n\nlet user = \"Jane User\";\n\ndocument.body.innerHTML = greeter(user);\n\n타입 어노테이션 (Type annotations)\nTypeScript의 타입 어노테이션은 함수 또는 변수의 의도된 계약을 적는 간단한 방법입니다.이 경우 greeter 함수를 단일 문자열 매개변수로 호출하려고 합니다.여기서 우리는 greeter 함수에 문자열 대신 배열을 전달하여 호출할 수도 있을 것입니다:\nfunction greeter(person: string) {\n    return \"Hello, \" + person;\n}\n\nlet user = [0, 1, 2];\n\ndocument.body.innerHTML = greeter(user);\n\n다시 컴파일하면, 오류가 표시됩니다.\nerror TS2345: Argument of type 'number[]' is not assignable to parameter of type 'string'.\n\n마찬가지로, greeter 호출할 때 모든 인수를 제거해보세요.TypeScript는 예상치 못한 매개변수로 함수를 호출했다는 것을 알려줍니다.두 경우 모두 TypeScript는 코드 구조와 사용자가 제공한 타입 어노테이션을 기반으로 정적 분석을 제공할 수 있습니다.\n에러가 있었음에도 불구하고, greeter.js 파일은 여전히 생성됩니다.코드에 오류가 있어도 TypeScript를 사용할 수 있습니다.그러나 이 경우에 TypeScript는 코드가 예상대로 실행되지 않을 것이라고 경고합니다.\n인터페이스 (Interfaces)\n예제를 더 발전시켜 봅시다. 여기서는 firstName 및 lastName 필드가 있는 객체를 설명하는 인터페이스를 사용합니다.TypeSciprt에서는 두가지 타입이 내부 구조가 호환되면 호환됩니다.이것은 명시적으로 implements 구문 없이 인터페이스가 요구하는 형태를 가짐으로써 인터페이스를 구현할 수 있게 해줍니다.\ninterface Person {\n    firstName: string;\n    lastName: string;\n}\n\nfunction greeter(person: Person) {\n    return \"Hello, \" + person.firstName + \" \" + person.lastName;\n}\n\nlet user = { firstName: \"Jane\", lastName: \"User\" };\n\ndocument.body.innerHTML = greeter(user);\n\n클래스 (Classes)\n마지막으로 클래스를 사용하여 예제를 확장해 보겠습니다.TypeScript는 클래스 기반 객체 지향 프로그래밍과 같은 JavaScript의 새로운 기능을 지원합니다.\n여기서는 생성자와 몇 개의 public 필드를 사용하여 Student 클래스를 생성 할 것입니다.클래스와 인터페이스가 잘 작동하여 프로그래머가 올바른 수준의 추상화를 결정할 수 있습니다.\n또한 생성자에 대한 인수에 public 을 사용하는 것은 그 이름으로 속성을 자동으로 생성 할 수 있는 단축형태입니다.\nclass Student {\n    fullName: string;\n    constructor(public firstName: string, public middleInitial: string, public lastName: string) {\n        this.fullName = firstName + \" \" + middleInitial + \" \" + lastName;\n    }\n}\n\ninterface Person {\n    firstName: string;\n    lastName: string;\n}\n\nfunction greeter(person : Person) {\n    return \"Hello, \" + person.firstName + \" \" + person.lastName;\n}\n\nlet user = new Student(\"Jane\", \"M.\", \"User\");\n\ndocument.body.innerHTML = greeter(user);\n\ntsc greeter.ts 를 다시 실행하면 생성된 JavaScript가 이전 코드와 동일하다는 것을 알 수 있습니다.TypeScript의 클래스는 JavaScript에서 자주 사용되는 것과 동일한 프로토 타입 기반 OO의 줄임말입니다.\nTypeScript 웹 앱 실행하기 (Running your TypeScript web app)\n이제 greeter.html 에 다음을 입력하세요:\n\n\n    TypeScript Greeter\n    \n        \n    \n\n\n첫번째 간단한 TypeScript 웹 애플리케이션을 실행하기 위해 브라우저에서 greeter.html 을 여세요!\n옵션 : Visual Studio에서 greeter.ts 를 열거나 코드를 TypeScript 플레이그라운드로 복사하세요.식별자 위로 마우스를 가져가면 타입을 볼 수 있습니다.경우에 따라 이러한 타입이 자동으로 추론됩니다.마지막 줄을 다시 입력하고 DOM 요소의 타입에 따라 완료 목록 및 매개변수 도움말을 확인하세요.greeter 함수에 대한 참조에 커서를 놓고 F12 키를 눌러 해당 정의로 이동할 수 있습니다.기호를 마우스 오른쪽 버튼으로 클릭하고 리팩토링을 사용하여 심볼의 이름을 바꿀 수 있습니다.\n제공된 타입 정보는 애플리케이션 규모에서 JavaScript로 작업할수 있는 도구와 함께 작동합니다.TypeScript에서 가능한 모든 예제는 웹 사이트의 샘플 섹션을 참조하세요.\n\n"},"pages/tutorials/ASP.NET Core.html":{"url":"pages/tutorials/ASP.NET Core.html","title":"ASP.NET Core","keywords":"","body":"설정\nASP.NET 코어 및 TypeScript 설치 (Install ASP.NET Core and TypeScript)\n먼저 필요한 경우에는 ASP.NET Core를 설치합니다.이 퀵 스타트 가이드를 위해서는 VisualStudio2015 또는 2017이 필요합니다.\n다음으로 사용 중인 VisualStudio에 최신 TypeScript가 아직 없는 경우 이를 설치할 수 있습니다.\n새 프로젝트 만들기 (Create a new project)\n\n파일 선택\n새로운 프로젝트 선택 (Ctrl + Shift + N)\nVisual C# 선택\nVS2015의 경우 ASP.NET Web Application > ASP.NET 5 Empty를 선택하고 로컬에서 실행하기 때문에 \"Host in the cloud\" 선택을 취소합니다.\n \n VS2017의 경우 ASP.NET Core Web Application (.NET Core) 대신 ASP.NET Core 1.1 Empty 를 선택하세요.\n \n\n\n애플리케이션을 실행하고 작동하는지 확인합니다.\n서버 설정 (Set up the server)\nVS2015\nproject.json에서 \"dependencies\"에 다음 항목을 추가합니다 :\n\"Microsoft.AspNet.StaticFiles\": \"1.0.0-rc1-final\"\n\n의존성은 다음과 같아야 합니다 :\n  \"dependencies\": {\n    \"Microsoft.AspNet.IISPlatformHandler\": \"1.0.0-rc1-final\",\n    \"Microsoft.AspNet.Server.Kestrel\": \"1.0.0-rc1-final\",\n    \"Microsoft.AspNet.StaticFiles\": \"1.0.0-rc1-final\"\n  },\n\nStartup.cs에서 Configure를 다음으로 교체합니다.\npublic void Configure(IApplicationBuilder app)\n{\n    app.UseIISPlatformHandler();\n    app.UseDefaultFiles();\n    app.UseStaticFiles();\n}\n\nVS2017\nOpen Dependencies > Manage NuGet Packages > Browse. 검색 및 설치  Microsoft.AspNetCore.StaticFiles 1.1.2:\n\nStartup.cs에서 Configure를 다음으로 교체합니다.\npublic void Configure(IApplicationBuilder app)\n{\n    app.UseDefaultFiles();\n    app.UseStaticFiles();\n}\n\nUseDefaultFiles와 UseStaticFiles 아래의 빨간선이 사라지려면 VS를 다시 시작해야 할 수 있습니다.\n타입스크립트 추가 (Add TypeScript)\n다음 단계는 TypeScript를 위한 폴더를 추가하는 것입니다.\n\n그냥 scripts라고 부르겠습니다.\n\n타입스크립트 코드 추가 (Add TypeScript code)\nscripts를 마우스 오른쪽 버튼으로 클릭하고 New Item을 클릭합니다.그런 다음 TypeScript File (.NET Core 섹션에 있을 수도 있음)을 선택하고 app.ts의 이름을 지정합니다.\n\n예제 코드 추가 (Add example code)\napp.ts에 다음 코드를 입력하십시오\nfunction sayHello() {\n    const compiler = (document.getElementById(\"compiler\") as HTMLInputElement).value;\n    const framework = (document.getElementById(\"framework\") as HTMLInputElement).value;\n    return `Hello from ${compiler} and ${framework}!`;\n}\n\n빌드 설정 (Set up the build)\nTypeScript 컴파일러 설정 (Configure the TypeScript compiler)\n먼저 TypeScript에 빌드 방법을 알려줘야 합니다.scripts 폴더를 마우스 오른쪽 버튼으로 클릭하고 New Item을 클릭합니다.그런 다음 TypeScript ConfigurationFile을 선택하고 기본 이름인 tsconfig.json을 사용하십시오.\n\n기본 tsconfig.json를 다음으로 대체하세요:\n{\n  \"compilerOptions\": {\n      \"noImplicitAny\": true,\n      \"noEmitOnError\": true,\n      \"sourceMap\": true,\n      \"target\": \"es5\"\n  },\n  \"files\": [\n      \"./app.ts\"\n  ],\n  \"compileOnSave\": true\n}\n\n다음과 같은 차이점을 제외하고 기본값과 유사합니다.\n\n\"noImplicitAny\": true 설정합니다.\n\"excludes\"에 의존하지 않고 명시적으로 \"files\" 리스트를 나열합니다.\n\"compileOnSave\": true 설정합니다.\n\n새로운 코드를 작성할 때마다 \"nomaplicitany\"가 좋습니다 - — 실수로 타입이 지정되지 않은 코드를 쓰지 않도록 할 수 있습니다.\"compileOnSave\"는 실행 중인 웹 앱에서 코드를 손쉽게 업데이트할 수 있도록 해 준다.\nNPM 설정 (Set up NPM)\n이제 JavaScript 패키지를 다운로드할 수 있도록 NPM을 설정해야 합니다.프로젝트를 마우스 오른쪽 버튼으로 누르고 New Item을 클릭하십시오.그런 다음 NPM Configuration File을 선택하고 기본 이름 package.json을 사용하십시오.  \ndevDependencies '안에 \"gulp\"와 \"del\"을 추가하십시오 :\n\"devDependencies\": {\n    \"gulp\": \"3.9.0\",\n    \"del\": \"2.2.0\"\n}\n\nVisual Studio는 파일을 저장하는 즉시 gulp 및 del 설치를 시작해야 합니다.그렇지 않은 경우 패키지를 마우스 오른쪽 버튼으로 누르고 Restore Packages를 하십시오.\ngulp 설정 (Set up gulp)\n마지막으로 gulpfile.js라는 새로운 JavaScript파일을 추가하십시오.\n다음 코드를 입력합니다.\n/// \n/*\n이 파일은 Gulp의 작업을 정의하고 플러그인을 사용하기 위한 entry point입니다.\n자세한 내용을 보려면 여기를 클릭하십시오. http://go.microsoft.com/fwlink/?LinkId=518007\n*/\n\nvar gulp = require('gulp');\nvar del = require('del');\n\nvar paths = {\n    scripts: ['scripts/**/*.js', 'scripts/**/*.ts', 'scripts/**/*.map'],\n};\n\ngulp.task('clean', function () {\n    return del(['wwwroot/scripts/**/*']);\n});\n\ngulp.task('default', function () {\n    gulp.src(paths.scripts).pipe(gulp.dest('wwwroot/scripts'))\n});\n\n첫 번째 줄은 Visual Studio에게 빌드가 끝난 후에 작업을 'default'로 실행하도록 지시합니다.또한 Visual Studio에 빌드를 정리하도록 요청하면 'clean'작업도 실행됩니다.\n이제 gulpfile.js를 마우스 오른쪽 버튼으로 클릭하고 Task Runner Explorer를 클릭하십시오.'default' 및 'clean'작업이 표시되지 않으면 탐색기를 새로고침 합니다 :\n\nHTML 페이지 작성 (Write an HTML page)\nwwwroot 안에 index.html이라는 새 항목을 추가합니다.\n다음 코드를 index.html에 사용합니다 :\n\n\n\n    \n    \n    \n\n\n    \n    \n        Compiler: \n        Framework: \n    \n\n\n\n테스트 (Test)\n\n프로젝트를 실행하십시오.\n입력 상자에 입력할 때 메시지가 표시됩니다 :\n\n\n디버그 (Debug)\n\nEdge에서 F12 키를 누르고 Debugger 탭을 클릭하십시오.\n첫 번째 localhost 폴더를 찾은 다음 scripts/app.ts를 찾습니다.\nreturn 라인이 있는 라인에 breakpoint를 설정합니다\nType 상자에 내용을 입력하고 breakpoint가 TypeScript 코드에 들어가고 검사가 올바르게 작동하는지 확인합니다.\n\n\nASP.NET 프로젝트에 기본적인 TypeScript를 포함시키기 위해 알아야 할 것은 이것뿐입니다.다음으로 간단한 Angular 앱을 작성합니다.\n앵귤러 2 추가 (Add Angular 2)\nNPM 의존성 추가 (Add NPM dependencies)\npackage.json의 dependencies에 Angular 2와 SystemJS를 추가하십시오.\nVS2015의 경우는 새로운 dependencies 리스트 :\n  \"dependencies\": {\n    \"angular2\": \"2.0.0-beta.11\",\n    \"systemjs\": \"0.19.24\",\n    \"gulp\": \"3.9.0\",\n    \"del\": \"2.2.0\"\n  },\n\nVS2017의 경우 NPM3에서 peer 의존성이 사용되지 않으므로 Angular 2의 peer 의존성을 의존성으로 직접 나열해야 합니다 :\n  \"dependencies\": {\n    \"angular2\": \"2.0.0-beta.11\",\n    \"reflect-metadata\": \"0.1.2\",\n    \"rxjs\": \"5.0.0-beta.2\",\n    \"zone.js\": \"^0.6.4\",\n    \"systemjs\": \"0.19.24\",\n    \"gulp\": \"3.9.0\",\n    \"del\": \"2.2.0\"\n  },\n\ntsconfig.json 업데이트 (Update tsconfig.json)\n이제 Angular 2와 그 의존성이 설치되었으므로 TypeScript의 데코레이터에 대한 실험적 지원이 필요합니다.또한 Promise과 같은 것들에는 Angular가 core-js를 사용하기 때문에 ES2015에 선언을 추가해야 합니다.향후에는 데코레이터가 기본이 될 것이므로 이러한 설정은 필요하지 않을 것입니다.\n\"experimentalDecorators\": true, \"emitDecoratorMetadata\": true를 \"compilerOptions\"에 추가하십시오.그런 다음 ES2015에서 선언을 가져오려면 \"lib\": [\"es2015\", \"es5\", \"dom\"]을 \"compilerOptions\" 에 추가하십시오.  \n마지막으로 만들 \"./model.ts\"를 \"files\"에 새 항목을 추가해야 합니다.tsconfig는 다음과 같이 보일 것입니다 :\n{\n    \"compilerOptions\": {\n        \"noImplicitAny\": true,\n        \"noEmitOnError\": true,\n        \"sourceMap\": true,\n        \"experimentalDecorators\": true,\n        \"emitDecoratorMetadata\": true,\n        \"target\": \"es5\",\n        \"lib\": [\n            \"es2015\", \"es5\", \"dom\"\n        ]\n    },\n    \"files\": [\n        \"./app.ts\",\n        \"./model.ts\",\n        \"./main.ts\"\n    ],\n    \"compileOnSave\": true\n}\n\ngulp 빌드에 Angular 추가 (Add Angular to the gulp build)\n마지막으로 Angular 파일을 빌드의 일부로 복사해야 합니다.\n추가할 사항은 다음과 같습니다:\n\n라이브러리 파일에 대한 경로.\nlib 태스크를 추가하여 파일을 wwwroot에 연결(pipe) 합니다.\ndefault 태스크에 lib에 대한 의존성을 추가하십시오.\n\n업데이트된 gulpfile.js은 다음과 같이 표시됩니다 :\n/// \n/*\n이 파일은 Gulp의 작업을 정의하고 플러그인을 사용하기 위한 entry point입니다.\n자세한 내용을 보려면 여기를 클릭하십시오. http://go.microsoft.com/fwlink/?LinkId=518007\n*/\n\nvar gulp = require('gulp');\nvar del = require('del');\n\nvar paths = {\n    scripts: ['scripts/**/*.js', 'scripts/**/*.ts', 'scripts/**/*.map'],\n    libs: ['node_modules/angular2/bundles/angular2.js',\n           'node_modules/angular2/bundles/angular2-polyfills.js',\n           'node_modules/systemjs/dist/system.src.js',\n           'node_modules/rxjs/bundles/Rx.js']\n};\n\ngulp.task('lib', function () {\n    gulp.src(paths.libs).pipe(gulp.dest('wwwroot/scripts/lib'));\n});\n\ngulp.task('clean', function () {\n    return del(['wwwroot/scripts/**/*']);\n});\n\ngulp.task('default', ['lib'], function () {\n    gulp.src(paths.scripts).pipe(gulp.dest('wwwroot/scripts'));\n});\n\n다시 한번 gulpfile을 저장한 후에는 Task Runner Explorer가 새로운 lib 작업을 보게해야 합니다.\nTypeScript에 간단한 Angular 애플리케이션 작성 (Write a simple Angular app in TypeScript)\n먼저 app.ts의 코드를 다음과 같이 변경하십시오 :\nimport {Component} from \"angular2/core\"\nimport {MyModel} from \"./model\"\n\n@Component({\n    selector: `my-app`,\n    template: `Hello from {{getCompiler()}}`\n})\nexport class MyApp {\n    model = new MyModel();\n    getCompiler() {\n        return this.model.compiler;\n    }\n}\n\n그런 다음 Model.ts라는 이름의 scripts에 다른 TypeScript 파일을 추가하십시오 :\nexport class MyModel {\n    compiler = \"TypeScript\";\n}\n\n그리고 scripts에 main.ts라는 또 다른 TypeScript 파일이 있습니다 :\nimport {bootstrap} from \"angular2/platform/browser\";\nimport {MyApp} from \"./app\";\nbootstrap(MyApp);\n\n마지막으로 index.html의 코드를 다음과 같이 변경하십시오 :\n\n\n\n    \n    \n    \n    \n    \n    \n    System.config({\n        packages: {\n            'scripts': {\n                format: 'cjs',\n                defaultExtension: 'js'\n            }\n        }\n    });\n    System.import('scripts/main').then(null, console.error.bind(console));\n    \n    \n\n\n    Loading...\n\n\n\n그러면 앱이 로드됩니다.ASP.NET 애플리케이션을 실행하면 \"loading...\" 이라고 표시된 다음 \"Hello from TypeScript\" div가 표시됩니다.\n"},"pages/tutorials/Gulp.html":{"url":"pages/tutorials/Gulp.html","title":"걸프","keywords":"","body":"이 퀵 스타트 가이드는 gulp로 TypeScript를 빌드한 다음 Browserify, uglify 또는 Watchify를 gulp 파이프 라인에 추가하는 방법을 알려줍니다.\n또한 Babelify를 사용하여 Babel 기능에 대한 기능을 추가합니다.npm과 함께 Node.js는 이미 사용하고 있다고 가정합니다.\n작은 프로젝트 (Minimal project)\n새로운 디렉토리부터 시작합시다.\n당장은 proj라고 이름을 붙이겠지만 원하는 대로 변경할 수 있습니다.\nmkdir proj\ncd proj\n\n시작하려면 다음과 같은 방식으로 프로젝트를 구조화해야 합니다:\nproj/\n   ├─ src/\n   └─ dist/\n\nTypeScript 파일은 src 폴더에서 시작하여 TypeScript 컴파일러를 통해 실행되고 dist에서 끝납니다.\n이것을 골격으로 합니다:\nmkdir src\nmkdir dist\n\n프로젝트 초기화 (Initialize the project)\n이제 이 폴더를 npm 패키지로 바꿀 것입니다.\nnpm init\n\n일련의 알림을 받게 될 것입니다.entry point를 제외하고는 기본값을 사용할 수 있으며 ./dist/main.js를 사용합니다.package.json 파일로 돌아가서 언제든 변경할 수 있습니다.\n의존성 설치 (Install our dependencies)\n이제는 npm install을 사용하여 패키지를 설치할 수 있습니다.먼저 gulp-cli를 글로벌 설치하십시오 (Unix 시스템을 사용하는 경우 npm install 명령 앞에 sudo를 붙여야 할 수도 있습니다).\nnpm install -g gulp-cli\n\n그런 다음 프로젝트의 개발자 의존성에 typescript, gulp 및 gulp-typescript를 설치하십시오.Gulp-typescript는 Typescript의 gulp 플러그인입니다.\nnpm install --save-dev typescript gulp gulp-typescript\n\n간단한 예제 작성 (Write a simple example)\nHello World 프로그램을 작성해 보겠습니다.\nsrc에 main.ts 파일을 만듭니다 :\nfunction hello(compiler: string) {\n    console.log(`Hello from ${compiler}`);\n}\nhello(\"TypeScript\");\n\nproj이라는 프로젝트 루트에 tsconfig.json 파일을 생성합니다 :\n{\n    \"files\": [\n        \"src/main.ts\"\n    ],\n    \"compilerOptions\": {\n        \"noImplicitAny\": true,\n        \"target\": \"es5\"\n    }\n}\n\ngulpfile.js 생성 (Create a gulpfile.js)\n프로젝트 루트에 gulpfile.js 파일을 만듭니다 :\nvar gulp = require(\"gulp\");\nvar ts = require(\"gulp-typescript\");\nvar tsProject = ts.createProject(\"tsconfig.json\");\n\ngulp.task(\"default\", function () {\n    return tsProject.src()\n        .pipe(tsProject())\n        .js.pipe(gulp.dest(\"dist\"));\n});\n\nresulting 앱 테스트 (Test the resulting app)\ngulp\nnode dist/main.js\n\n프로그램에서 \"Hello from TypeScript!\"를 인쇄해야합니다.\n코드에 모듈 추가 (Add modules to the code)\nBrowserify를 시작하기 전에 코드를 만들고 믹스에 모듈을 추가해 보겠습니다.이것은 실제 앱에서 사용하기 쉬운 구조입니다.\nsrc/greet.ts 파일을 만듭니다 :\nexport function sayHello(name: string) {\n    return `Hello from ${name}`;\n}\n\n이제 src/main.ts의 sayHello를 greet.ts에서 가져오도록 변경합니다 :\nimport { sayHello } from \"./greet\";\n\nconsole.log(sayHello(\"TypeScript\"));\n\n마지막으로 src/greet.ts를 tsconfig.json에 추가하십시오 :\n{\n    \"files\": [\n        \"src/main.ts\",\n        \"src/greet.ts\"\n    ],\n    \"compilerOptions\": {\n        \"noImplicitAny\": true,\n        \"target\": \"es5\"\n    }\n}\n\ngulp을 실행하고 노드에서 테스트하여 모듈이 작동하는지 확인하십시오 :\ngulp\nnode dist/main.js\n\nES2015 모듈 구문을 사용했지만 TypeScript는 Node가 사용하는 CommonJS 모듈을 방출했습니다.이 튜토리얼에서는 CommonJS를 계속 사용하겠지만 options 객체에 module을 설정하여 이를 변경할 수 있습니다.  \nBrowserify\n이제 이 프로젝트를 노드에서 브라우저로 이동하겠습니다.이를 위해 모든 모듈을 하나의 JavaScript 파일로 번들링 하고자 합니다.다행히도 정확히 Browserify가 하는 일입니다.더 좋은 것은 노드에서 사용하는 CommonJS 모듈 시스템을 TypeScript에서 사용할 수 있다는 것입니다.즉 TypeScript와 Node 설정이 기본적으로 변경되지 않은 브라우저로 전송되는 것을 의미합니다.\n먼저 browserify, tsify 및 vinyl-source-stream을 설치하십시오.tsify는 gulp-typescript처럼 Typeify 컴파일러에 접근할 수 있는 Browserify 플러그인입니다.vinyl-source-stream을 사용하면 Browserify의 파일 출력을 gulp에서 vinyl으로 인식하는 형식으로 다시 변환할 수 있습니다.\nnpm install --save-dev browserify tsify vinyl-source-stream\n\n페이지 만들기 (Create a page)\nsrc에 index.html 파일을 생성합니다 :\n\n\n    \n        \n        Hello World!\n    \n    \n        Loading ...\n        \n    \n\n\n이제 main.ts를 변경하여 페이지를 업데이트하십시오 :\nimport { sayHello } from \"./greet\";\n\nfunction showHello(divName: string, name: string) {\n    const elt = document.getElementById(divName);\n    elt.innerText = sayHello(name);\n}\n\nshowHello(\"greeting\", \"TypeScript\");\n\nshowHello 호출은 sayHello를 호출하여 paragraph 텍스트를 변경합니다.이제 gulpfile을 다음과 같이 변경하십시오 :\nvar gulp = require(\"gulp\");\nvar browserify = require(\"browserify\");\nvar source = require('vinyl-source-stream');\nvar tsify = require(\"tsify\");\nvar paths = {\n    pages: ['src/*.html']\n};\n\ngulp.task(\"copy-html\", function () {\n    return gulp.src(paths.pages)\n        .pipe(gulp.dest(\"dist\"));\n});\n\ngulp.task(\"default\", [\"copy-html\"], function () {\n    return browserify({\n        basedir: '.',\n        debug: true,\n        entries: ['src/main.ts'],\n        cache: {},\n        packageCache: {}\n    })\n    .plugin(tsify)\n    .bundle()\n    .pipe(source('bundle.js'))\n    .pipe(gulp.dest(\"dist\"));\n});\n\ncopy-html 태스크를 추가하고 default의 의존성으로 추가합니다.default가 실행될 때마다 copy-html이 먼저 실행되어야 한다는 것을 의미합니다.또한 default를 gulp-typescript 대신 tsify 플러그인으로 Browserify를 호출하도록 변경했습니다.편리하게도 둘 모두 TypeScript 컴파일러에 동일한 options 객체를 전달할 수 있습니다.\nbundle을 호출한 후 source(vinil-source-stream에 대한 별칭)를 사용하여 출력 번들 bundle.js의 이름을 지정합니다.\ngulp를 실행하고 브라우저에서 dist/index.html을 열어 페이지를 테스트하십시오.페이지에 \"Hello from TypeScript\"가 표시되어야 합니다.\nBrowserify에 debug : true를 지정한 것에 주목하십시오.이로 인해 tsify는 번들 JavaScript 파일 내에서 소스맵을 내보냅니다.소스 맵을 사용하면 번들로 제공된 JavaScript 대신 브라우저에서 원본 TypeScript 코드를 디버깅할 수 있습니다.브라우저의 디버거를 열고 main.ts 안에 브레이크포인트을 넣으면 소스 맵이 작동하는지 테스트할 수 있습니다.페이지를 새로 고침 할 때 브레이크포인트가 페이지를 일시 중지하고 greet.ts를 디버깅 할 수 있도록 해야 합니다.\nWatchify, Babel, and Uglify\n이제 코드를 Browserify에 묶어서 tsify 했으므로 browserify 플러그인을 사용하여 빌드에 다양한 기능을 추가할 수 있습니다.\n\nWatchify가 gulp를 계속 실행하며 파일을 저장할 때마다 점차적으로 컴파일합니다.이를 통해 브라우저에서 편집-저장-새로고침 사이클을 계속 진행할 수 있습니다.\n\nBabel은 ES2015 이상을 ES5 및 ES3으로 변환하는 매우 유연한 컴파일러입니다.따라서 TypeScript에서 지원하지 않는 광범위한 맞춤형 변환을 추가할 수 있습니다.\n\nUglify는 다운로드 시간을 줄이도록 코드를 압축합니다.\n\n\nWatchify\nWatchify로 백그라운드 컴파일을 시작하겠습니다 :\nnpm install --save-dev watchify gulp-util\n\n이제 gulpfile을 다음과 같이 변경하십시오 :\nvar gulp = require(\"gulp\");\nvar browserify = require(\"browserify\");\nvar source = require('vinyl-source-stream');\nvar watchify = require(\"watchify\");\nvar tsify = require(\"tsify\");\nvar gutil = require(\"gulp-util\");\nvar paths = {\n    pages: ['src/*.html']\n};\n\nvar watchedBrowserify = watchify(browserify({\n    basedir: '.',\n    debug: true,\n    entries: ['src/main.ts'],\n    cache: {},\n    packageCache: {}\n}).plugin(tsify));\n\ngulp.task(\"copy-html\", function () {\n    return gulp.src(paths.pages)\n        .pipe(gulp.dest(\"dist\"));\n});\n\nfunction bundle() {\n    return watchedBrowserify\n        .bundle()\n        .pipe(source('bundle.js'))\n        .pipe(gulp.dest(\"dist\"));\n}\n\ngulp.task(\"default\", [\"copy-html\"], bundle);\nwatchedBrowserify.on(\"update\", bundle);\nwatchedBrowserify.on(\"log\", gutil.log);\n\n여기에는 기본적으로 세 가지 변경 사항이 있지만 코드를 약간 리팩토링해야합니다.\n\nwatchify에 대한 호출에서 browserify 인스턴스를 감싸고 그 결과를 유지했습니다.\nwatchedBrowserify.on(\"update\", bundle);을 호출하여 Browserify 가 TypeScript 파일 중 하나가 변경될 때마다 bundle 함수를 실행하도록 했습니다.\nwatchedBrowserify.on(\"log\", gutil.log);을 호출하여 콘솔에 로그했습니다.\n\n(1)과 (2)는 default 작업에서 browserify를 호출해야 한다는 것을 의미합니다.Watchify와 Gulp 모두 호출해야 하기 때문에 default 함수에 이름을 주어야 합니다.(3)을 사용한 로깅을 추가하는 것은 선택 사항이지만 설정을 디버깅하는 데 매우 유용합니다.\n이제 Gulp를 실행하면 시작해야 하고 계속 실행됩니다.main.ts에서 showHello에 대한 코드를 변경하고 저장하십시오.  \n다음과 같은 출력이 표시되어야 합니다 :\nproj$ gulp\n[10:34:20] Using gulpfile ~/src/proj/gulpfile.js\n[10:34:20] Starting 'copy-html'...\n[10:34:20] Finished 'copy-html' after 26 ms\n[10:34:20] Starting 'default'...\n[10:34:21] 2824 bytes written (0.13 seconds)\n[10:34:21] Finished 'default' after 1.36 s\n[10:35:22] 2261 bytes written (0.02 seconds)\n[10:35:24] 2808 bytes written (0.05 seconds)\n\nUglify\n먼저 Uglify를 설치하십시오.Uglify의 요점은 코드를 압축하기 위한 것이므로 소스 맵을 유지하려면 vinyl-buffer와 gulp-sourcemaps도 설치해야 합니다.\nnpm install --save-dev gulp-uglify vinyl-buffer gulp-sourcemaps\n\n이제 gulpfile을 다음과 같이 변경하십시오 :\nvar gulp = require(\"gulp\");\nvar browserify = require(\"browserify\");\nvar source = require('vinyl-source-stream');\nvar tsify = require(\"tsify\");\nvar uglify = require('gulp-uglify');\nvar sourcemaps = require('gulp-sourcemaps');\nvar buffer = require('vinyl-buffer');\nvar paths = {\n    pages: ['src/*.html']\n};\n\ngulp.task(\"copy-html\", function () {\n    return gulp.src(paths.pages)\n        .pipe(gulp.dest(\"dist\"));\n});\n\ngulp.task(\"default\", [\"copy-html\"], function () {\n    return browserify({\n        basedir: '.',\n        debug: true,\n        entries: ['src/main.ts'],\n        cache: {},\n        packageCache: {}\n    })\n    .plugin(tsify)\n    .bundle()\n    .pipe(source('bundle.js'))\n    .pipe(buffer())\n    .pipe(sourcemaps.init({loadMaps: true}))\n    .pipe(uglify())\n    .pipe(sourcemaps.write('./'))\n    .pipe(gulp.dest(\"dist\"));\n});\n\nuglify 자체에는 하나의 호출만 있습니다 — buffer와 sourcemaps에 대한 호출은 sourcemaps이 계속 작동하는지 확인하기 위해 존재합니다.이러한 호출을 통해 이전과 같이 인라인 소스 맵을 사용하는 대신 별도의 소스 맵 파일을 사용할 수 있습니다.이제 Gulp를 실행하고 bundle.js가 난독화로 압축되는지 확인하십시오 :\ngulp\ncat dist/bundle.js\n\nBabel\n먼저 ES2015 전용 Babelify 및 Babel preset을 설치하십시오.Uglify처럼 Babelify도 코드를 엉망으로 만들기 때문에 vinyl-buffer와 gulp-sourcemaps이 필요합니다.기본적으로 Babelify는 확장자가 .js, .es, .es6 및 .jsx 인 파일만 처리하므로 Babelify에 옵션으로 .ts 확장자를 추가해야 합니다.\nnpm install --save-dev babelify babel-core babel-preset-es2015 vinyl-buffer gulp-sourcemaps\n\n이제 gulpfile을 다음과 같이 변경하십시오 :\nvar gulp = require('gulp');\nvar browserify = require('browserify');\nvar source = require('vinyl-source-stream');\nvar tsify = require('tsify');\nvar sourcemaps = require('gulp-sourcemaps');\nvar buffer = require('vinyl-buffer');\nvar paths = {\n    pages: ['src/*.html']\n};\n\ngulp.task('copyHtml', function () {\n    return gulp.src(paths.pages)\n        .pipe(gulp.dest('dist'));\n});\n\ngulp.task('default', ['copyHtml'], function () {\n    return browserify({\n        basedir: '.',\n        debug: true,\n        entries: ['src/main.ts'],\n        cache: {},\n        packageCache: {}\n    })\n    .plugin(tsify)\n    .transform('babelify', {\n        presets: ['es2015'],\n        extensions: ['.ts']\n    })\n    .bundle()\n    .pipe(source('bundle.js'))\n    .pipe(buffer())\n    .pipe(sourcemaps.init({loadMaps: true}))\n    .pipe(sourcemaps.write('./'))\n    .pipe(gulp.dest('dist'));\n});\n\nTypeScript 대상 ES2015도 필요합니다.Babel은 TypeScript에서 내보내는 ES2015 코드에서 ES5를 생성합니다.\ntsconfig.json을 수정합시다 :\n{\n    \"files\": [\n        \"src/main.ts\"\n    ],\n    \"compilerOptions\": {\n        \"noImplicitAny\": true,\n        \"target\": \"es2015\"\n    }\n}\n\nBabel의 ES5 출력은 간단한 스크립트에 대한 TypeScript의 출력과 매우 유사해야 합니다.\n"},"pages/tutorials/Migrating from JavaScript.html":{"url":"pages/tutorials/Migrating from JavaScript.html","title":"JavaScript에서 마이그레이션","keywords":"","body":"TypeScript는 공백 상태로 존재하지 않습니다.JavaScript 생태계를 염두에 두고 만들어졌으며 오늘날에는 많은 JavaScript가 존재합니다.JavaScript 코드 베이스를 TypeScript로 변환하는 것은 다소 지루하지만 보통 어렵지 않습니다.이 튜토리얼에서는 시작하는 방법을 살펴보겠습니다.새로운 TypeScript 코드를 작성하기에 충분한 핸드북을 읽은 것으로 가정합니다.\nReact 프로젝트를 변환하려는 경우 React Conversion Guide를 먼저 참조하는 것이 좋습니다.\n디렉토리 설정하기 (Setting up your Directories)\n평범한 JavaScript로 작성하는 경우 JavaScript가 src와 lib 또는 dist 디렉토리에 있는 .js 파일을 직접 실행하고 원하는 대로 실행할 수 있습니다.\n이런 경우 작성한 파일은 TypeScript의 입력으로 사용되며 생성된 출력을 실행하게 됩니다.JS에서 TS로 마이그레이션 하는 동안 TypeScript가 입력 파일을 덮어쓰지 않도록 입력 파일을 분리해야 합니다.출력 파일이 특정 디렉토리에 있어야 하는 경우 해당 파일이 출력 디렉토리가 됩니다.\n번들링이나 Babel과 같은 다른 트랜스파일러를 사용하는 것과 같이 JavaScript에서 중간 단계를 수행할 수도 있습니다.이런 경우에는 이와 같은 폴더 구조가 이미 설정되어 있을 수 있습니다.\n지금부터 디렉토리가 다음과 같이 설정되었다고 가정할 것입니다:\nprojectRoot\n├── src\n│   ├── file1.js\n│   └── file2.js\n├── built\n└── tsconfig.json\n\nsrc 디렉토리 밖에 tests 폴더가 있다면 src에 tsconfig.json와 tests에 하나씩 가질 수 있습니다.\n설정 파일 작성하기 (Writing a Configuration File)\nTypeScript는 tsconfig.json이라는 파일을 사용하여 포함시킬 파일과 검사의 종류와 같은 프로젝트의 옵션을 관리합니다.프로젝트에 사용할 기본적인 뼈대를 생성하겠습니다:\n{\n    \"compilerOptions\": {\n        \"outDir\": \"./built\",\n        \"allowJs\": true,\n        \"target\": \"es5\"\n    },\n    \"include\": [\n        \"./src/**/*\"\n    ]\n}\n\n여기서 TypeScript에 몇 가지를 지정합니다:\n\nsrc 디렉토리에의 모든 파일을 읽습니다 (include 포함)\nJavaScript 파일의 입력으로 허용합니다 (allowJs 포함)\nbuiltd에 모든 출력 파일을 내 보냅니다 (outDir와 함께)\n최신 JavaScript 구문을 ECMAScript 5 같은 이전 버전으로 변환합니다 (target 사용)\n\n이때 프로젝트 루트에 tsc를 실행하려고 하면 built 디렉토리에 출력 파일이 표시됩니다.built에 있는 파일의 레이아웃은 src의 레이아웃과 동일해야 합니다.이제 프로젝트에서 TypeScript로 작업해야 합니다.\n초기의 혜택 (Early Benefits)\n이 시점에서도 TypeScript에서 프로젝트를 이해함으로써 몇 가지 뛰어난 이점을 누릴 수 있습니다.VS Code나 Visual Studio 같은 편집기로 시작하면 자동 완성과 같은 도구 지원을 자주 받을 수 있습니다.또한 다음과 같은 옵션을 사용하여 특정 버그를 발견할 수도 있습니다:\n\nnoImplicitReturns는 함수의 끝에 반환문을 빼먹는 것을 방지합니다.\nnoFallthroughCasesInSwitch는 switch블록 case 사이에 break문을 뻬먹지 않기 위해 유용합니다.\n\nTypeScript는 도달 할 수없는 코드와 라벨에 대해서도 경고합니다.이 코드와 라벨은 각각의 allowUnreachableCode와 allowUnusedLabels로 해제할 수 있습니다.\n빌드 도구와 통합 (Integrating with Build Tools)\n파이프 라인에 빌드 단계가 더 있을 수 있습니다.아마도 각 파일에 무언가를 연결했을 것입니다.각 빌드 도구는 다르지만 각 빌드 도구의 요점을 다루기 위해 최선을 다할 것입니다.\nGulp\nGulp를 사용하는 경우 TypeScript로 Gulp 사용하기 튜토리얼이 있고 Browserify와 Babelify 그리고 Uglify와 같은 일반적인 빌드 도구와 통합됩니다.거기서 더 읽을 수 있습니다.\nWebpack\nWebpack 통합은 매우 간단합니다.\nTypeScript 로더인 awesome-typescript-loader를 source-map-loader와 결합하여 사용하면 디버깅이 쉬워 집니다.  \n간단한 실행\nnpm install awesome-typescript-loader source-map-loader\n\n그리고 다음의 옵션을 webpack.config.js 파일에 병합하십시오 :\nmodule.exports = {\n    entry: \"./src/index.ts\",\n    output: {\n        filename: \"./dist/bundle.js\",\n    },\n\n    // webpack의 출력을 디버깅 할 소스 맵을 사용하도록 설정합니다.\n    devtool: \"source-map\",\n\n    resolve: {\n        // 확인 가능한 확장자로 '.ts' 및 '.tsx'를 추가합니다.\n        extensions: [\"\", \".webpack.js\", \".web.js\", \".ts\", \".tsx\", \".js\"]\n    },\n\n    module: {\n        loaders: [\n            // '.ts' 또는 '.tsx' 확장자를 가진 모든 파일은 'awesome-typescript-loader'에 의해 처리됩니다.\n            { test: /\\.tsx?$/, loader: \"awesome-typescript-loader\" }\n        ],\n\n        preLoaders: [\n            // '.js' 파일의 모든 출력에는 'source-maps-loader'로 다시 처리된 소스 맵이 있습니다.\n            { test: /\\.js$/, loader: \"source-map-loader\" }\n        ]\n    },\n\n    // 다른 옵션들...\n};\n\n.js 파일을 다루는 다른 로더보다 awesome-typescript-loader를 먼저 실행해야 한다는 점에 주의해야 합니다.Webpack을 위한 TypeScript 로더인 ts-loader도 마찬가지입니다.여기에서. 그 둘의 차이점에 대해 더 읽어볼 수 있다. \nReact and Webpack에 관한 튜토리얼에서 Webpack을 사용하는 예를 볼 수 있습니다.\nTypeScript 파일로 이동 (Moving to TypeScript Files)\n이때 TypeScript 파일을 사용할 준비가 된 것입니다.첫 번째 단계는 .js 파일 중 하나의 이름을 .ts로 바꾸는 것입니다.파일이 JSX를 사용한다면 이름을 .tsx로 바꿔야 합니다.\n그 단계를 끝냈나요?\n좋았어!JavaScript에서 TypeScript로 파일을 성공적으로 마이그레이션 했습니다!\n물론 옳다고 생각하지 않을 수도 있습니다.TypeScript를 지원하는 편집기에서 해당 파일을 열면 (또는 tsc --pretty를 실행하면) 특정 라인에 빨간 줄이 나타날 수 있습니다.Microsoft Word와 같은 편집기에서 빨간 줄을 생각하는 것과 같은 방식으로 생각해야합니다.Word에서 여전히 문서를 인쇄할 수 있는 것처럼 TypeScript는 코드를 변환합니다.\n그 경고가 너무 느슨하면 그 경고를 엄격하게 할 수 있습니다.예를 들어 오류 발생으로 인해 TypeScript에서 JavaScript로 컴파일하는 것을 원치 않는 경우 noEmitOnError 옵션을 사용할 수 있습니다.그런 의미에서 TypeScript는 엄격함을 조절할 수 있는 도구를 가지고 있으며 원하는 만큼 조절할 수 있습니다.\n만약 사용 가능한 더 엄격한 설정을 사용할 계획이라면 지금 바로 설정하는 것이 가장 좋습니다.(아래의 Getting Stricter Checks 참조).\n예를 들어 TypeScript가 타입에 대해 any를 추론하지 않도록 명시하려면 파일을 수정하기 전에 noImplicitAny를 사용할 수 있습니다.다소 벅차다고 느껴질 수도 있지만 장기적 이득은 훨씬 더 빨리 나타납니다.\n오류 잡기 (Weeding out Errors)\n앞서 언급 한 것처럼 변환 후에 오류 메시지가 표시되는 것은 예상치 못한 일이 아닙니다.중요한 것은 이런 것들을 하나씩 살펴보고 어떻게 오류를 처리할 것인지를 결정하는 것입니다.종종 이것들은 문제없는 버그가 될 수도 있지만 때로는 TypeScript를 위해 조금 더 나은 것을 설명해야 할 것입니다.\n모듈 가져오기 (Importing from Modules)\nCannot find name 'require'.와 Cannot find name 'define'. 같은 오류가 발생하기 시작할 수 있습니다.이러한 경우 모듈을 사용하고 있을 가능성이 높습니다.\nTypeScript로 작성하는 동안 확실할 수 있지만\n// Node/CommonJS를 위한\ndeclare function require(path: string): any;\n\n또는\n// RequireJS/AMD를 위한\ndeclare function define(...args: any[]): any;\n\n이러한 호출들은 제거하고 import에 TypeScript 구문을 사용하는 것이 좋습니다.\n먼저 TypeScript의 module 플래그를 설정하여 일부 모듈 시스템을 활성화해야 합니다.유효한 옵션은commonjs,amd,system 그리고 umd입니다.\n다음 Node/CommonJS 코드를 가지고 있는 경우:\nvar foo = require(\"foo\");\n\nfoo.doStuff();\n\n또는 다음 RequireJS / AMD 코드:\ndefine([\"foo\"], function(foo) {\n    foo.doStuff();\n})\n\n그러면 다음과 같은 TypeScript 코드를 작성하게 됩니다:\nimport foo = require(\"foo\");\n\nfoo.doStuff();\n\n선언 파일 가져 오기 (Getting Declaration Files)\nTypeScript로 전환하기 시작하면 Cannot find module 'foo'.과 같은 오류가 발생할 수 있습니다.여기서 문제는 라이브러리를 설명할 수 있는 선언 파일(declaration files) 을 가지고 있지 않다는 것입니다.다행히도 이것은 꽤 쉽습니다.TypeScript에서 lodash와 같은 패키지에 대해 불평하는 경우 그냥 작성할 수 있습니다.\nnpm install -S @types/lodash\n\ncommonjs가 아닌 다른 모듈 옵션을 사용한다면 moduleResolution 옵션을 node로 설정해야 합니다.\n그런 다음 문제없이 Lodash를 가져올 수 있으며 자동 완성을 얻을 수 있습니다.\n모듈 내보내기 (Exporting from Modules)\n전형적으로 모듈에서 내보내기는 exports 나 module.exports와 같은 값에 프로퍼티를 추가하는 것을 포함합니다.TypeScript를 사용하면 최상위 레벨 내보내기 명령문을 허용할 수 있습니다.\n예를 들어 이와 같은 함수를 내보낸 경우:\nmodule.exports.feedPets = function(pets) {\n    // ...\n}\n\n다음과 같이 작성할 수 있습니다:\nexport function feedPets(pets) {\n    // ...\n}\n\n때로는 exports 객체를 완전히 덮어쓰기도 합니다.\n이것은 모듈을 이 코드처럼 즉시 호출 가능한 모듈로 만들기 위해 사용하는 일반적인 패턴입니다:\nvar express = require(\"express\");\nvar app = express();\n\n이전에는 이렇게 작성했을 수도 있습니다 :\nfunction foo() {\n    // ...\n}\nmodule.exports = foo;\n\nTypeScript에서는 이것을 export = 구조로 모델링할 수 있습니다.\nfunction foo() {\n    // ...\n}\nexport = foo;\n\n너무 많거나 적은 인수 (Too many/too few arguments)\n때때로 너무나 많거나 적은 인수를 가진 함수를 호출할 때가 있습니다.전형적으로 이것은 버그이지만 어떤 경우에는 매개 변수를 쓰는 대신 arguments 객체를 사용하는 함수를 선언했을 수도 있습니다:\nfunction myCoolFunction() {\n    if (arguments.length == 2 && !Array.isArray(arguments[1])) {\n        var f = arguments[0];\n        var arr = arguments[1];\n        // ...\n    }\n    // ...\n}\n\nmyCoolFunction(function(x) { console.log(x) }, [1, 2, 3, 4]);\nmyCoolFunction(function(x) { console.log(x) }, 1, 2, 3, 4);\n\n이런 경우에는 TypeScript를 사용하여 myCoolfunction이 함수 오버로드를 통해 호출될 수 있는 방법에 대해 알려주어야 합니다.\nfunction myCoolFunction(f: (x: number) => void, nums: number[]): void;\nfunction myCoolFunction(f: (x: number) => void, ...nums: number[]): void;\nfunction myCoolFunction() {\n    if (arguments.length == 2 && !Array.isArray(arguments[1])) {\n        var f = arguments[0];\n        var arr = arguments[1];\n        // ...\n    }\n    // ...\n}\n\nmyCoolFunction에 두 개의 오버로드를 추가했습니다.\n첫 번째 검사는 myCoolFunction가 (number를 갖는) 함수에 number의 목록을 가집니다.\n두번째는 함수도 갖춰야 한다는 것이고 그 뒤에 오는 인수가 숫자여야 한다는 것을 알리기 위해 나머지 매개변수(...nums)를 사용합니다.\n순차적으로 추가되는 프로퍼티 (Sequentially Added Properties)\n어떤 사람들은 다음과 같이 즉시 객체를 생성하고 속성을 추가하는 것이 더 예술적으로 즐겁다는 것을 알게됩니다:\nvar options = {};\noptions.color = \"red\";\noptions.volume = 11;\n\nTypeScript는 options의 타입을 어떠한 프로퍼티도 갖지 않는 {}로 먼저 찾아냈기 때문에 volume과 color에 할당할 수 없다고 말할 것입니다.대신 선언을 객체 리터럴 자체로 옮기면 오류가 발생하지 않습니다:\nlet options = {\n    color: \"red\",\n    volume: 11\n};\n\noptions의 타입을 정의하고 객체 리터럴에 타입 단언(type assertion)을 추가 할 수도 있습니다.\ninterface Options { color: string; volume: number }\n\nlet options = {} as Options;\noptions.color = \"red\";\noptions.volume = 11;\n\n또는 options에 any 타입이라고 하는 것이 가장 쉬운 방법이지만 가장 이득이 적은 일이 될 것입니다.\nany와 Object 그리고 {} (any, Object, and {})\n대부분의 경우 Object가 가장 일반적인 타입이기 때문에 Object 또는 {}를 사용하여 값에 프로퍼티를 포함할 수 있다고 말할 수 있습니다.하지만 any가 가장 유연한 타입이기 때문에 이러한 상황에서 실제로 사용하려는 타입입니다.\n예를 들어 Object 타입을 가지고 있다면 toLowerCase()와 같은 메서드를 호출할 수 없습니다.  \n좀 더 일반적이라는 것은 보통 타입을 사용하는 것이 적다는 것을 의미하지만 가장 일반적인 타입인 any는 여전히 어떤 것이든 할 수 있게 허용해준다는 점에서 특별합니다.즉 호출하여 구성하고 프로퍼티를 조작할 수 있습니다.하지만 any를 사용하면 TypeScript가 제공하는 대부분의 오류 검사 및 편집기 지원을 잃어 버리게 됩니다.\nObject와 {}로 판결났다면 {}을 선호해야 합니다.그것들은 대체로 같지만 비밀스러운 경우에는 기술적으로 {}가 Object보다 더 일반적인 타입입니다.\n엄격한 검사 받기 (Getting Stricter Checks)\nTypeScript는 프로그램의 안전성과 분석을 제공하기 위해 특정 검사를 제공합니다.일단 코드 베이스를 TypeScript로 변환한 후에는 이러한 검사를 활성화하여 안전성을 높일 수 있습니다.\n암시적인 any는 No (No Implicit any)\n타이프 스크립트가 어떤 타입이어야 할지 모르는 특정한 경우가 있습니다.가능하면 관대하기 위해 그 자리에 any 타입을 사용하기로 결정할 것입니다.이는 마이 그레이션에는 매우 유용하지만 any를 사용하면 어떠한 유형의 안전도 확보할 수 없으며 다른 곳에서 얻을 수 있는 것과 도구의 지원을 받을 수 없습니다.TypeScript에서 이러한 위치를 기록하도록 지시하고 noImplicitAny 옵션으로 오류를 표시할 수 있습니다.\n엄격한 null과 undefined 체크 (Strict null & undefined Checks)\n기본적으로 TypeScript는 null과 undefined이 모든 타입의 범위에 있다고 가정합니다.즉 number 타입으로 선언된 모든 것이 null 또는 undefined 일 수 있음을 의미합니다.  \nnull과 undefined는 JavaScript와 TypeScript에서 자주 발생하는 버그의 원천이기 때문에 TypeScript는 이에 대한 걱정을 덜어주기 위해 strictNullChecks 옵션을 가지고 있습니다.  \nstrictNullChecks가 활성화되면 null과 undefined는 null과 undefined 각각의 타입을 갖습니다.\n혹시 null 일 수 있는 항목이 있을 때 원래 타입을 union 타입으로 사용할 수 있습니다.그렇기 때문에 타입이 number(이)거나 null 일 수 있는 경우 해당 타입을 number | null로 쓰면 됩니다.\nTypeScript가 null /undefined라고 생각하는 값을 가지고 있지만 더 잘 알고 있다면 후위 연산자 !를 사용하여 다르게 사용할 수 있습니다.\ndeclare var foo: string[] | null;\n\nfoo.length;  // 오류 - 'foo'는 'null'일 수 있습니다.\n\nfoo!.length; // 좋아요 - 'foo!'에 'string[]'타입이 있습니다.\n\n참고로 strictNullChecks를 사용할 때는 strictNullChecks도 사용하기 위해 의존성을 업데이트해야 할 수도 있습니다.\n묵시적인 this의 any No! (No Implicit any for this)\n클래스 밖에서 this 키워드를 사용할 때 기본적으로 any 타입을 가집니다.\n예를 들어 Point 클래스를 생각하여 메서드로 추가하고자 하는 함수를 작성해보세요 :\nclass Point {\n    constructor(public x, public y) {}\n    getDistance(p: Point) {\n        let dx = p.x - this.x;\n        let dy = p.y - this.y;\n        return Math.sqrt(dx ** 2 + dy ** 2);\n    }\n}\n// ...\n\n// 인터페이스를 다시 열어보세요\ninterface Point {\n    distanceFromOrigin(point: Point): number;\n}\nPoint.prototype.distanceFromOrigin = function(point: Point) {\n    return this.getDistance({ x: 0, y: 0});\n}\n\n이것은 위에서 언급한 것과 동일한 문제를 가지고 있습니다 - getDistance의 철자가 틀리거나 오류가 발생하지 않을 수 있습니다.이러한 이유로 TypeScript는 noImplicitThis 옵션을 가지고 있습니다.이 옵션을 설정하면 TypeScript에서 명시적(또는 추론된) 타입 없이 this를 사용할 경우 오류가 발생합니다.\n해결책은 인터페이스나 함수 자체에 this-매개변수를 사용하여 명확한 타입을 제공하는 것입니다:\nPoint.prototype.distanceFromOrigin = function(this: Point, point: Point) {\n    return this.getDistance({ x: 0, y: 0});\n}\n\n"},"pages/tutorials/React & Webpack.html":{"url":"pages/tutorials/React & Webpack.html","title":"리액트 & 웹팩","keywords":"","body":"이 가이드에서는 TypeScript를 React와 webpack으로 묶는 방법을 가르쳐줄 것입니다.\n새로운 프로젝트를 시작하려면 먼저 React Quick Start guide를 살펴보세요.\n그렇지 않으면 npm과 Node.js를 이미 사용하고 있다고 가정합니다.\n프로젝트 배치 (Lay out the project)\n새로운 디렉토리부터 시작합시다. 지금은 이름을 proj로 지정했지만 원하는대로 변경할 수 있습니다.\nmkdir proj\ncd proj\n\n시작하려면 다음과 같은 방식으로 프로젝트를 구성해야합니다:\nproj/\n├─ dist/\n└─ src/\n   └─ components/\n\nTypeScript 파일은 src 폴더에서 시작한 TypeScript는 컴파일 후 webpack을 실행하여 dist의 bundle.js 파일로 끝납니다.작성된 모든 구성 요소는src / components 폴더에 들어갑니다.\n이것을 골격으로 합니다:\nmkdir src\ncd src\nmkdir components\ncd ..\n\nWebpack은 결국 dist 디렉토리를 생성할 것입니다.\n프로젝트 초기화 (Initialize the project)\n이제 이 폴더를 npm 패키지로 바꿀 것입니다.\nnpm init\n\n주의사항이 표시되지만 기본값을 자유롭게 사용할 수 있습니다.사용자를 위해 생성된 package.json 파일에서 언제든 기본값을 변경할 수 있습니다.\n의존성 설치 (Install our dependencies)\n먼저 Webpack이 글로벌으로 설치되어 있는지 확인해보세요.\nnpm install -g webpack\n\nWebpack은 사용자의 코드를 번들(묶어서)로 제공하고 선택적으로 모든 의존성을 단 하나의 .js 파일로 번들링(묶는)하는 도구입니다.\n이제 React와 React-DOM을 package.json 파일의 의존성으로 추가하겠습니다:\nnpm install --save react react-dom @types/react @types/react-dom\n\n@types/ 접두사는 React와 React-DOM을 위한 선언 파일을 가져온다는 것을 의미합니다.일반적으로 \"react\"와 같은 경로를 가져 오면 react 패키지 자체를 살펴봅니다.그러나 모든 패키지가 선언 파일을 포함하는 것은 아니므로 TypeScript는 또한 @types/react 패키지를 찾습니다.나중에는 이 일에 대해 생각할 필요도 없다는 걸 알게 될 것입니다.\n다음으로 awesome-typescript-loader와 source-map-loader에 development-time 의존성을 추가할 것입니다.\nnpm install --save-dev typescript awesome-typescript-loader source-map-loader\n\n이러한 의존성 둘 다 TypeScript와 webpack이 함께 잘 작동하도록 할 것 입니다.awesome-typescript-loader는 Webpack이 TypeScript의 표준 구성 파일 tsconfig.json을 사용하여 TypeScript 코드를 컴파일하는 데 도움이 됩니다.source-map-loader는 TypeScript의 모든 소스 맵 출력을 사용하여 자체 소스 맵을 생성 할 때 webpack에 알립니다.이렇게하면 원래 TypeScript 소스 코드를 디버깅 하듯이 최종 출력 파일을 디버깅 할 수 있습니다.\nawesome-typescript-loader가 typescript의 유일한 로더는 아닙니다.대신 ts-loader를 사용할 수 있습니다.여기에서  두 로더 사이의 차이점에 대해 읽어보세요.\n개발 의존성으로 TypeScript를 설치했음을 주목하십시오.TypeScript를 npm link typescript로 글로벌 사본에 연결할 수 있었는데 이것은 흔치 않은 경우입이다.\nTypeScript 설정 파일 추가 (Add a TypeScript configuration file)\nTypeScript 파일을 함께 가져오고 싶다면 필요한 선언 파일뿐만 아니라 작성할 코드 모두 작성하세요.\n이렇게 하려면 모든 컴파일 설정과 함께 입력 파일 목록이 포함된 tsconfig.json을 생성해야 합니다.프로젝트 루트에 tsconfig.json이라는 이름의 새 파일을 만들고 내용을 다음과 같이 채우기만 하면 됩니다:\n{\n    \"compilerOptions\": {\n        \"outDir\": \"./dist/\",\n        \"sourceMap\": true,\n        \"noImplicitAny\": true,\n        \"module\": \"commonjs\",\n        \"target\": \"es5\",\n        \"jsx\": \"react\"\n    },\n    \"include\": [\n        \"./src/**/*\"\n    ]\n}\n\ntsconfig.json 파일에 대한 자세한 내용은 여기를 참조하십시오.\n몇 가지 코드 작성 (Write some code)\nReact를 사용하여 첫 번째 TypeScript 파일을 작성해 보겠습니다.먼저src/components에 Hello.tsx라는 이름의 파일을 만들고 다음과 같이 작성합니다:\nimport * as React from \"react\";\n\nexport interface HelloProps { compiler: string; framework: string; }\n\nexport const Hello = (props: HelloProps) => Hello from {props.compiler} and {props.framework}!;\n\n이 예제에서는 stateless functional components를 사용하는 경우에 대비하여 예제를 좀 더 고급스럽게 만들 수도 있습니다.\nimport * as React from \"react\";\n\nexport interface HelloProps { compiler: string; framework: string; }\n\n// 'HelloProps'는 props의 형태을 만듭니다.\n// State가 설정되어 있지 않아 '{}'타입을 사용합니다.\nexport class Hello extends React.Component {\n    render() {\n        return Hello from {this.props.compiler} and {this.props.framework}!;\n    }\n}\n\n그런 다음 src에 index.tsx를 생성해 봅시다 :\nimport * as React from \"react\";\nimport * as ReactDOM from \"react-dom\";\n\nimport { Hello } from \"./components/Hello\";\n\nReactDOM.render(\n    ,\n    document.getElementById(\"example\")\n);\n\nHello 컴포넌트를 index.tsx로 가져왔습니다.\"react\" 또는 \"react-dom\"과 달리 Hello.tsx에 대한 상대 경로를 사용했음을 주목하세요 - 이것은 중요합니다.그렇지 않다면 TypeScript는 대신node_modules 폴더를 살펴 보았을 겁니다.\n또한 Hello 컴포넌트를 보여줄 페이지가 필요합니다.다음과 같은 내용을 담은 index.html파일을 proj의 루트에 만듭니다:\n\n\n    \n        \n        Hello React!\n    \n    \n        \n\n        \n        \n        \n\n        \n        \n    \n\n\nnode_modules에서 파일을 포함하고 있음을 주목하십시오.React와 React-DOM의 npm 패키지에는 웹 페이지에 포함할 수 있는 독립적인 .js 파일이 포함되어 있으며이를 빠르게 위해 직접 참조하고 있습니다.\n이러한 파일을 다른 디렉토리에 자유롭게 복사하거나 CDN을 통해 호스팅하는 것이 좋습니다.페이스북은 React의 CDN 호스팅 버전을 제공하며 여기에서 더 자세한 내용을 볼 수 있습니다.\n웹팩 설정 파일 만들기 (Create a webpack configuration file)\n프로젝트의 루트에 webpack.config.js 파일을 만듭니다.\nmodule.exports = {\n    entry: \"./src/index.tsx\",\n    output: {\n        filename: \"bundle.js\",\n        path: __dirname + \"/dist\"\n    },\n\n    // webpack의 출력을 디버깅 할 소스 맵을 사용하도록 설정합니다.\n    devtool: \"source-map\",\n\n    resolve: {\n        // 확인 가능한 확장자로 '.ts' 및 '.tsx'를 추가합니다.\n        extensions: [\".ts\", \".tsx\", \".js\", \".json\"]\n    },\n\n    module: {\n        rules: [\n            // '.ts' 또는 '.tsx' 확장자를 가진 모든 파일은 'awesome-typescript-loader'에 의해 처리됩니다.\n            { test: /\\.tsx?$/, loader: \"awesome-typescript-loader\" },\n\n            // '.js' 파일의 모든 출력에는 'source-maps-loader'로 다시 처리된 소스 맵이 있습니다.\n            { enforce: \"pre\", test: /\\.js$/, loader: \"source-map-loader\" }\n        ]\n    },\n\n    // 경로가 다음 중 하나와 일치하는 모듈을 임포트 경우\n    // 해당하는 글로벌 변수가 있다고 가정하고 대신 사용하세요.\n    // 이는 브라우저가 빌드와 라이브러리 사이에 캐시 할 수 있게 해주는\n    // 모든 종속성을 번들로 묶는 것을 피할 수 있기 때문에 중요합니다.\n    externals: {\n        \"react\": \"React\",\n        \"react-dom\": \"ReactDOM\"\n    },\n};\n\n아마도 externals 필드에 대해 궁금해 할지도 모릅니다.이렇게 하면 컴파일 시간이 증가하고 브라우저가 일반적으로 라이브러리를 변경하지 않을 경우 캐시 할 수 있으므로 모든 React 파일을 동일한 파일로 번들링하는 것을 방지합니다.\n이상적으로는 브라우저에서 React 모듈을 임포트하는 것 뿐이지만 대부분의 브라우저들은 아직도 모듈을 완전히 지원하지 않습니다.대신 라이브러리는 전통적으로 jQuery 나 _와 같은 글로벌 하게 사용하여 자체적으로 사용할 수 있게 했습니다.이를 \"네임 스페이스 패턴\"이라고 하며 webpack을 사용하면 이러한 방식으로 작성된 라이브러리를 계속 활용할 수 있습니다.\n\"react\"에 대한 entry를 사용하면 : webpack은 \"React\" 변수에서 \"react\"를 불러오기 위해 마술을 사용합니다.\nwebpack 설정에 대한 자세한 내용은 여기를 참조하십시오.\n모든 것을 함께 모아서 (Putting it all together)\n실행 :\nwebpack\n\n이제 즐겨 찾는 브라우저에 index.html을 열면 모든 것을 사용할 준비가 될 것입니다!\"Hello from TypeScript and React!\"라고 쓰인 페이지가 보일 겁니다.\n"},"pages/Basic Types.html":{"url":"pages/Basic Types.html","title":"기본 타입","keywords":"","body":"소개 (Introduction)\n프로그램을 유용하게 사용하려면 숫자, 문자열, 구조, 부울 값 등과 같은 몇 가지 간단한 데이터 단위로 작업할 수 있어야 합니다. TypeScript에서는 사용자가 JavaScript에서 기대하는 것과 같은 타입을 지원하며 이를 지원하기 위해 편리한 열거형을 포함합니다.\n부울 (Boolean)\n가장 기본적인 데이터 타입은 JavaScript와 TypeScript가 boolean 값을 호출하는 단순한 true / false 값입니다.\nlet isDone: boolean = false;\n\n숫자형 (Number)\nJavaScript와 마찬가지로 TypeScript의 모든 숫자는 부동 소수 점 값입니다.이 부동 소수 점 숫자는 number 타입을 받습니다.TypeScript는 10진수 및 16진수와 함께 ECMAScript2015에 도입된 2진수 및 8진수 문자를 지원합니다.\nlet decimal: number = 6;\nlet hex: number = 0xf00d;\nlet binary: number = 0b1010;\nlet octal: number = 0o744;\n\n문자열 (String)\n웹 페이지와 서버를 위한 JavaScript 프로그램을 만드는 또 다른 기본적인 부분은 텍스트 데이터를 사용하는 것입니다.다른 언어와 같이 이러한 텍스트의 데이터 타입을 참조하기 위해 string 타입을 사용합니다.JavaScript와 마찬가지로 TypeScript 또한 문자열 데이터를 감싸기 위해 큰 따옴표(\") 또는 작은 따옴표(')를 사용합니다.\nlet color: string = \"blue\";\ncolor = 'red';\n\n여러 줄에 걸쳐 표현식을 포함할 수 있는 템플릿 문자열 을 사용할 수도 있습니다.이 문자열은 백틱 / 백 쿼트 (` ) 문자로 감싸져 있으며 포함된 표현식은 ${ 표현식 } 형식입니다.\nlet fullName: string = `Bob Bobbington`;\nlet age: number = 37;\nlet sentence: string = `Hello, my name is ${ fullName }.\n\nI'll be ${ age + 1 } years old next month.`;\n\n이것은 위와 같이 선언한 문장과 같습니다.\nlet sentence: string = \"Hello, my name is \" + fullName + \".\\n\\n\" +\n    \"I'll be \" + (age + 1) + \" years old next month.\";\n\n배열 (Array)\nTypeScript는 JavaScript와 같이 값의 배열을 사용할 수 있도록 합니다.배열의 타입은 두 가지 방법 중 하나로 작성 될 수 있습니다.\n첫번째, 요소 타입의 배열을 나타내기 위해 [] 다음에 오는 요소의 타입을 사용합니다.\nlet list: number[] = [1, 2, 3];\n\n두 번째 방법으로는 제네릭 배열 타입을 사용합니다. Array:\nlet list: Array = [1, 2, 3];\n\n튜플 (Tuple)\n튜플 타입은 고정된 개수의 요소 타입을 알고 있지만 반드시 같을 필요는 없는 배열을 표현할 수 있도록 합니다.예를 들어, 다음과 같은 string과 number의 쌍으로 값을 나타낼 수 있습니다 :\n// 튜플 타입 선언\nlet x: [string, number];\n// 초기화\nx = [\"hello\", 10]; // 좋아요\n// 부정확한 초기화\nx = [10, \"hello\"]; // 오류\n\n알려진 인덱스을 사용하여 요소에 접근하는 경우에 올바른 타입이 검색됩니다.\nconsole.log(x[0].substr(1)); // 좋아요\nconsole.log(x[1].substr(1)); // 오류, 'number'은 'substr'을 가지고 있지 않습니다.\n\n알려진 인덱스 집합 외부의 요소에 접근할 때는 다음과 같이 Union 타입이 사용됩니다:\nx[3] = \"world\"; // 좋아요, 'string'은 'string | number'에 할당될 수 있습니다.\n\nconsole.log(x[5].toString()); // 좋아요, 'string' 및 'number'에 모두 'toString'이 있습니다.\n\nx[6] = true; // 오류, 'boolean'은 'string | number' 타입이 아닙니다.\n\n유니온 타입은 다음 장에서 다루게 될 고급 주제입니다.\n열거 (Enum)\nJavaScript의 표준 데이터 타입 집합에 추가할 수 있는 유용하고 부가적인 추가 자료는 enum 입니다.C#와 같은 언어에서처럼 enum은 numeric 값 집합에 더 친숙한 이름을 부여하는 방법이다.\nenum Color {Red, Green, Blue}\nlet c: Color = Color.Green;\n\n기본적으로 enums는 0부터 시작하는 자신의 멤버 번호를 매기기를 시작합니다.멤버 중 하나의 값을 수동으로 설정하여 이를 변경할 수 있습니다.예를 들어 이전 예제를 0 대신 1로 시작할 수 있습니다:\nenum Color {Red = 1, Green, Blue}\nlet c: Color = Color.Green;\n\n또는 열거 형의 모든 값을 수동으로 설정합니다:\nenum Color {Red = 1, Green = 2, Blue = 4}\nlet c: Color = Color.Green;\n\nenum의 편리한 기능은 숫자 값에서 enum의 해당 값 이름으로 이동할 수 있다는 것입니다.예를 들어, 값 2를 가지고 있지만 위의 Color enum에서 매핑된 값이 무엇인지 확실하지 않은 경우에 그에 상응하는 이름을 찾을 수 있습니다:\nenum Color {Red = 1, Green, Blue}\nlet colorName: string = Color[2];\n\nalert(colorName); // 위의 값이 2 이므로 'Green'을 표시합니다.\n\nAny\n어플리케이션을 작성할 때 알지 못하는 변수의 타입을 설명해야 할 수도 있습니다.이러한 값은 사용자 또는 써드-파티 라이브러리와 같은 동적 컨텐츠에서 비롯될 수 있습니다.이러한 경우에는, 타입 검사를 선택하지 않고 그 값이 컴파일-타임 검사를 통과하도록 하고 싶습니다.이를 위해 다음과 같은 any 타입으로 지정합니다.\nlet notSure: any = 4;\nnotSure = \"문자열일수도 있다\";\nnotSure = false; // 좋아요, 확실한 boolean\n\nany 타입은 기존 JavaScript로 작업할 수 있는 강력한 방법으로 컴파일 과정에서 타입 검사를 점진적으로 실행 (opt-in) 및 중지(opt-out) 할 수 있습니다.\n다른 언어와 마찬가지로 객체도 비슷한 역할을 할 것으로 예상할 수 있습니다.그러나 객체 타입의 변수를 사용하면 해당 객체에는 값만 할당할 수 있습니다 - 실제로 존재하는 것도 임의의 메서드를 호출할 수는 없습니다:\nlet notSure: any = 4;\nnotSure.ifItExists(); // 좋아요, 런타임에 ifItExists가 존재할 수 있습니다.\nnotSure.toFixed(); // 좋아요, toFixed는 존재합니다. (그러나 컴파일러는 체크하지 않습니다)\n\nlet prettySure: Object = 4;\nprettySure.toFixed(); // 오류: 'Object' 타입에 'toFixed' 프로퍼티는 존재하지 않습니다.\n\nany 타입은 일부를 알고 있는 경우에도 유용하지만 모두 그렇지는 않습니다.예를 들어 배열이 있지만 배열에는 다른 타입이 혼재되어 있습니다:\nlet list: any[] = [1, true, \"free\"];\n\nlist[1] = 100;\n\nVoid\nvoid는 any의 정반대이지만 조금 비슷합니다: 어떠한 타입의 부재도 전혀 없습니다.일반적으로 반환 값을 반환하지 않는 함수의 반환 타입으로 볼 수 있습니다:\nfunction warnUser(): void {\n    alert(\"This is my warning message\");\n}\n\nvoid 타입의 변수 선언은 undefined 또는 null 만 할당할 수 있으므로 유용하지 않습니다:\nlet unusable: void = undefined;\n\nNull 과 Undefined\nTypeScript에서 undefined와 null은 실제로 각기 undefined와 null이라는 자체적인 타입을 가집니다.void와 마찬가지로 그것들은 매우(극단적으로) 유용하지 않습니다 :\n// 그 외에도 이러한 변수에 할당할 수 있습니다!\nlet u: undefined = undefined;\nlet n: null = null;\n\n기본적으로 null과 undefined는 다른 모든 타입의 서브 타입입니다.즉 null과 undefined를 number와 같은 것으로 할당 할 수 있습니다.\n그러나 --strictNullChecks 플래그를 사용할 때 null과 undefined는 void와 그 각각의 타입에만 할당할 수 있습니다.이렇게 하면 많은 일반적인 오류를 피할 수 있습니다.string 또는 null 또는 undefined 중 하나를 전달하고자 하는 경우 string | null | undefined (union 타입)을 사용할 수 있습니다.다시 한 번 말하자면 이후에 더 많은 Union 타입에 관한 내용이 있습니다.\n\n메모: 가능한 한 --strictNullChecks 검사를 사용하도록 권장하지만 본 핸드북의 목적상 이 기능이 꺼져 있다고 가정하겠습니다.\n\nNever\nnever 타입은 절대로 발생하지 않는 값의 타입을 나타냅니다.예를 들어 never는 함수 표현식의 반환 타입이거나 항상 예외를 던지는 화살표 함수 표현식이거나 절대 반환하지 않는 표현식입니다.변수는 또한 never 일 때 타입 가드에 의해 좁혀지더라도 결코 사실일 수 없으며 타입을 획득하지 못합니다.\nnever 타입은 모든 타입의 서브 타입이며 모든 타입에 할당할 수 있습니다.어떤 타입도 never의 서브 타입이거나 할당 가능한 타입은 아닙니다 (never 자체를 제외하고).any 조차도 never에 할당할 수 없습니다.\nnever를 반환하는 함수의 몇 가지 예는 다음과 같습니다 :\n// 반환되는 함수에는 연결할 수 없는 end-point가 있어서는 안 됩니다.\nfunction error(message: string): never {\n    throw new Error(message);\n}\n\n// 추론되는 반환 타입은 절대로 없습니다.\nfunction fail() {\n    return error(\"Something failed\");\n}\n\n// 반환되는 함수에는 연결할 수 없는 end-point가 있어서는 안 됩니다.\nfunction infiniteLoop(): never {\n    while (true) {\n    }\n}\n\n타입 단언 (Type assertions)\n때로는 TypeScript보다 더 많은 값을 알아야 하는 상황에 놓일 수도 있습니다.일반적으로 이 문제는 일부 엔티티의 타입이 현재 타입보다 더 구체적일 수 있다는 것을 알고 있을 때 발생합니다.\nType assertions 은 컴파일러에게 \"나를 믿어, 내가 하고 있는 일을 안다\"라고 말하는 방법입니다.type assertion은 다른 언어의 형 변환(타입캐스팅)과 비슷하지만 특별한 검사나 데이터를 재구성하지는 않습니다.런타임에 영향을 미치지 않으며 컴파일러에서만 사용됩니다.TypeScript는 개발자가 필요한 특별한 검사를 수행했다고 가정합니다.\nType assertions은 두 가지 형태를 가집니다.하나는 \"angle-bracket\" (꺾쇠괄호) 구문입니다:\nlet someValue: any = \"this is a string\";\n\nlet strLength: number = (someValue).length;\n\n그리고 다른 하나는 구문은 as 입니다 :\nlet someValue: any = \"this is a string\";\n\nlet strLength: number = (someValue as string).length;\n\n두 샘플은 동일합니다.다른 하나를 사용하는 것은 주로 선호도에 따른 선택입니다.그러나 TypeScript를 JSX와 함께 사용할 때는 as 스타일의 단언만 허용됩니다.\nlet에 대한 메모\n지금까지 우리가 알고 있는 JavaScript의 var 키워드 대신 let 키워드를 사용했음을 알 수 있습니다.\nlet 키워드는 실제로 TypeScript에서 사용할 수 있는 더욱 새로운 JavaScript 구문입니다.나중에 더 자세히 논의하겠지만 JavaScript가 가지고 있는 많은 흔한 문제들은 let의 사용으로 해결할 수 있기 때문에 가능할 때마다 var 대신 let을 사용하는 것이 좋습니다.\n"},"pages/Variable Declarations.html":{"url":"pages/Variable Declarations.html","title":"변수 선언","keywords":"","body":"소개 (Introduction)\nlet과 const는 JavaScript에서 상대적으로 새로운 두 가지 유형의 변수 선언입니다.이전에 언급했듯이 let은 var와 유사하지만 사용자가 JavaScript로 실행하는 일반적인 \"결함\"을 피할 수 있습니다.const는 변수에 재 할당 할 수 없다는 점에서 let의 기능 확장입니다.\nTypeScript가 JavaScript의 상위 집합이기 때문에 자연스럽게 let과 const를 지원합니다.여기서 우리는 이 새로운 선언들에 대해 더 자세히 설명할 것이고 왜 그것들이 var보다 더 바람직한지를 자세히 설명 할 것입니다.\n만약 JavaScript를 아무렇게나 사용했다면 다음 섹션은 기억을 새롭게 하는 좋은 방법이 될 것입니다.JavaScript에서 var 선언의 모든 단점을 잘 알고 있다면 더 쉽게 건너뛸 수 있습니다.\nvar 선언 (var declarations)\n전통적으로 JavaScript에서 변수 선언은 var 키워드를 사용하였습니다.\nvar a = 10;\n\n알다시피 방금 a 변수의 값을 10 으로 선언하였습니다.\n또한 함수 내에서 변수를 선언할 수도 있습니다.\nfunction f() {\n    var message = \"Hello, world!\";\n\n    return message;\n}\n\n그리고 다른 함수 내부의 동일한 변수에 접근이 가능합니다.\nfunction f() {\n    var a = 10;\n    return function g() {\n        var b = a + 1;\n        return b;\n    }\n}\n\nvar g = f();\ng(); // 오류 '11'\n\n위의 예제에서 g함수는 f함수에서 선언된 변수 a를 흭득하였습니다.\ng함수가 호출되는 시점에 a의 값은 f함수 내에 a의 값에 연결됩니다.\nf함수가 실행되는 시점에 g함수가 호출되더라도 a에 접근하여 수정할 수 있습니다.\nfunction f() {\n    var a = 1;\n\n    a = 2;\n    var b = g();\n    a = 3;\n\n    return b;\n\n    function g() {\n        return a;\n    }\n}\n\nf(); // '2' 반환\n\n스코프 규칙 (Scoping rules)\nvar 선언은 다른 언어의 스코프 규칙에 비해 이상한 스코프 규칙이 몇가지 있습니다.다음 예를 함께 보겠습니다.\nfunction f(shouldInitialize: boolean) {\n    if (shouldInitialize) {\n        var x = 10;\n    }\n\n    return x;\n}\n\nf(true);  // '10' 반환\nf(false); // 'undefined' 반환\n\n어떤 독자는 이 예제를 두 번 실행해 볼 수도 있습니다.변수 x는 if 블록 내에 선언되어 있지만 블록의 바깥에서 접근할 수 있습니다.var 선언은 함수, 모듈, 네임 스페이스 또는 전역 스코프에서 접근할 수 있기 때문에 가능합니다.-포함된 블록에 관계없이 나중에 모두 다룰 것입니다.이것을 var-scoping 또는 function-scoping이라고 부릅니다.매개변수 또한 함수의 스코프입니다.\n이러한 스코프 규칙은 몇 가지 유형의 실수를 유발할 수 있습니다.그들이 악화시키는 한가지 문제점은 동일한 변수를 여러 번 선언하는 것은 실수가 아니라는 사실입니다.\nfunction sumMatrix(matrix: number[][]) {\n    var sum = 0;\n    for (var i = 0; i \n어쩌면 다소 쉽게 찾을 수도 있지만 for-loop 내에서 동일한 함수 스코프의 변수를 참조하기 때문에 실수로 변수 i 를 덮어 쓰게 됩니다.숙련된 개발자들은 알겠지만 비슷한 종류의 버그는 코드 리뷰에서 끝없는 좌절의 원인이 될 수 있다.\n변수 캡쳐링의 단점 (Variable capturing quirks)\n잠깐 다음 코드의 출력을 예상을 해보세요\nfor (var i = 0; i \n익숙하지 않은 사람들을 위해 setTimeout은 일정한 시간이 지나면 함수를 실행하려고 합니다.(실행이 멈추는 것을 기다리고 있습니다.)\n준비됐나요? 보세요:\n10\n10\n10\n10\n10\n10\n10\n10\n10\n10\n\n많은 JavaScript 개발자들은 이러한 동작에 친숙하지만 당신은 놀랐을 수도 있습니다.하지만 당신은 확실히 혼자가 아닙니다.\n대부분의 사람들은 이러한 결과를 기대합니다.\n0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n\n앞에서 변수 캡쳐링에 대해 언급한 내용 기억하세요?setTimeout에 전달하는 모든 함수 표현식은 실제로 동일한 스코프의 i를 참조합니다.\n이것이 무슨 뜻인지 한번 생각해 봅시다.setTimeout은 몇 밀리 초 후에 함수를 실행하지만 for 루프가 실행을 중지 한 후에 만 실행됩니다.for 루프가 실행을 중지했을 때 i 값은 10입니다. 따라서 주어진 함수가 호출될 때마다 10을 출력합니다!\n일반적인 해결 방법은 각 반복마다 i를 캡쳐하는 즉시 실행 함수 표현식인 IIFE를 사용하는 것입니다.\nfor (var i = 0; i \n위의 이상하게 생긴 패턴은 매우 일반적입니다.매개 변수 목록의 i는 for루프에 선언된 i와 같지만 동일한 네이밍을 했기 때문에 루프를 변경할 필요가 없었습니다.\nlet 선언 (let declarations)\n이제는 var에 몇 가지 문제가 있다는 것을 알아냈습니다.그 이유는 정확히 let이 도입 된 이유입니다.let은 var와 동일한 방식으로 작성됩니다.\nlet hello = \"Hello!\";\n\n중요한 차이점은 구문에 있는 것이 아니라 의미에 관한 것입니다.이제 이 내용을 살펴 보겠습니다.\n블록-스코프 (Block-scoping)\nlet을 사용하여 변수를 선언할 때 렉시컬-스코프 또는 블록-스코프를 사용합니다.스코프가 포함된 함수로 누출되는 var 변수와 달리 블록-스코프 변수는 가장 가깝게 포함된 블록 또는 for 반복문 외부에서 사용할 수 없습니다.\nfunction f(input: boolean) {\n    let a = 100;\n\n    if (input) {\n        // 'a'는 이곳에서 가능\n        let b = a + 1;\n        return b;\n    }\n\n    // 오류: 'b'는 여기에 존재하지 않습니다.\n    return b;\n}\n\n여기 두 개의 지역변수 a와 b가 있습니다.a의 스코프는 함수 f의 지역변수로 제한되어있고 b의 스코프는 if문 블록에 제한되어있습니다.\ncatch 문안에 선언된 변수에도 유사한 스코프의 스코프 규칙을 갖습니다.\ntry {\n    throw \"oh no!\";\n}\ncatch (e) {\n    console.log(\"Oh well.\");\n}\n\n// 오류: 'e'는 여기에 존재하지 않습니다.\nconsole.log(e);\n\n블록-스코프 변수의 또 다른 프로퍼티는 실제로 선언되기 전에는 읽거나 쓸 수 없다는 것입니다.이러한 변수는 스코프내에서 temporal dead zone 이 될 때까지 \"존재\"합니다.이것은 let 선언 이전에 변수에 먼저 접근 할수 없는 정교한 방법이며 다행스럽게도 TypeScript를 통해 알 수 있습니다.\na++; // 'a'를 선언하기전에 사용하는것은 불법입니다;\nlet a;\n\n주의해야 할 점은 블록-스코프 변수가 선언되기 전에 변수를 캡쳐할 수 있다는 것입니다.선언전에 해당 함수을 실행시키는 것은 불법이라는 것을 알 수 있습니다.\nES2015를 목표로 한다면 현대적인 런타임은 오류를 던질 것입니다.그러나 지금은 TypeScripts는 허용되며 오류로 보고하지 않습니다.\nfunction foo() {\n    // 'a'를 캡쳐합니다\n    return a;\n}\n\n// 잘못된 호출로 'foo'가 선언되기 전에 'a'가 선언됩니다.\n// 여기서 런타임 오류가 발생해야합니다.\nfoo();\n\nlet a;\n\nTemporal dead zone 에 대한 자세한 내용은 Mozilla 개발자 네트워크 의 관련 내용을 참조하십시오.\n재선언과 Shadowing (Re-declarations and Shadowing)\nvar 를 선언한 횟수가 중요하지 않다고 언급했습니다. 단지 변수를 하나 얻었을 뿐입니다.\nfunction f(x) {\n    var x;\n    var x;\n\n    if (true) {\n        var x;\n    }\n}\n\n위의 예에서 x의 모든 선언은 실제로 동일한 x를 참조하며 이는 완전히 유효합니다.이것은 종종 버그의 원인이 됩니다. 고맙게도 let 에서는 이런 것을 허용하지 않습니다.\nlet x = 10;\nlet x = 20; // 오류: 동일한 스코프에서 'x'를 다시 선언 할 수 없습니다.\n\nTypeScript의 블록-스코프는 두개의 같은 변수는 필요하지 않다고 우리에게 문제를 말해줍니다.\nfunction f(x) {\n    let x = 100; // 오류: 매개변수가 변수 선언에 간섭하고 있습니다.\n}\n\nfunction g() {\n    let x = 100;\n    var x = 100; // 오류: 'x'의 선언을 두 번 할 수 없습니다.\n}\n\n블록-스코프 변수가 함수-스코프 변수로 선언될 수 없다는 뜻은 아닙니다.블록-스코프 변수는 명확하게 다른 블록 내에서 선언되어야합니다.\nfunction f(condition, x) {\n    if (condition) {\n        let x = 100;\n        return x;\n    }\n\n    return x;\n}\n\nf(false, 0); // '0' 반환\nf(true, 0);  // '100' 반환\n\n중첩된 스코프에서 기존의 변수 이름을 사용하는 것을 shadowing 이라고 합니다. shadowing 은 우발적인 버그를 유발하는 동시에 버그를 예방할 수도 있다는 점에서 양날의 검입니다.\n예를 들어 let 변수를 사용하여 이전 sumMatrix 함수를 작성했다고 가정해 보겠습니다.\nfunction sumMatrix(matrix: number[][]) {\n    let sum = 0;\n    for (let i = 0; i \n이번 버전의 루프는 내부의 반복문의 i가 외부의 반복문의 i를 shadows하기때문에 실제로 계산을 합니다.\nShadowing은 보통 더 명확한 코드를 작성하기 위해 피해야 합니다.이를 활용할 수 있는 몇 가지 시나리오가 있을 수 있지만 최선의 판단을 내려야 합니다.\n블럭-스코프 변수 캡쳐\nvar 선언으로 변수 캡쳐를 처음 접했을 때 우리는 일단 캡쳐된 변수가 어떻게 작동하는지 간략하게 살펴보았습니다.이것에 대한 직감적이고 더 나은 직감을 주기 위해 스코프가 실행될 때마다 변수의 \"환경\"을 생성합니다.해당 환경 및 캡쳐 된 변수는 스코프 내의 모든 항목이 완료된 후에도 존재할 수 있습니다\nfunction theCityThatAlwaysSleeps() {\n    let getCity;\n\n    if (true) {\n        let city = \"Seattle\";\n        getCity = function() {\n            return city;\n        }\n    }\n\n    return getCity();\n}\n\n환경내에서 city를 캡쳐했으므로 if 블록이 실행을 완료 했음에도 불구하고 여전히 접근할 수 있습니다.\n이전의 setTimeout 예제에서 for 문을 반복할 때마다 변수의 상태를 캡쳐하기 위해 IIFE를 사용해야한다는 결론을 얻었습니다.실제로 하고 있던 것은 캡쳐한 변수를 위한 새로운 변수 환경을 만드는 것이었습니다.그것은 약간의 고통이었지만 다행스럽게도 TypeScript에서 그렇게 할 필요가 없습니다.\nlet은 루프의 일부로 선언될 때 크게 다른 동작을 합니다.루프 자체에 새로운 환경을 도입하기보다는 이러한 선언은 반복마다 새로운 스코프를 만듭니다.이것이 IIFE로 하고 있었던 것을 let 을 사용하여 이전의 setTimeout 예제를 바꿀 수 있습니다.\nfor (let i = 0; i \n예상한대로 출력됩니다.\n0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n\nconst 선언 (const declarations)\nconst 는 변수를 선언하는 또 다른 방법입니다.\nconst numLivesForCat = 9;\n\n그것은 let 선언과 같지만 그 이름에서 알 수 있듯이 바인딩 된 후에는 값을 변경할 수 없습니다.즉 let과 동일한 스코프 규칙을 가지고 있지만 규칙을 다시 할당할 수 없습니다.\n이것은 참조하는 값이 불변 이라는 개념과 혼동되어서는 안됩니다.\nconst numLivesForCat = 9;\nconst kitty = {\n    name: \"Aurora\",\n    numLives: numLivesForCat,\n}\n\n// 오류\nkitty = {\n    name: \"Danielle\",\n    numLives: numLivesForCat\n};\n\n// 모두 \"좋아요\"\nkitty.name = \"Rory\";\nkitty.name = \"Kitty\";\nkitty.name = \"Cat\";\nkitty.numLives--;\n\n이를 방지하기 위해 구체적인 조치를 취하지 않는 한 const변수의 내부 상태는 여전히 수정할 수 있습니다. 다행히 TypeScript를 사용하면 객체의 멤버를 readonly로 지정할 수 있습니다.\nInterfaces 챕터에서 자세한 내용을 다룹니다.\nlet vs. const\n비슷한 스코프 지정 의미론을 가진 두 가지 선언이 있다고 가정할 때 어떤 것을 사용할 것인지를 묻는 것은 당연합니다.대부분의 질문들과 같이 그 대답도 다음과 같습니다: 그것은 다릅니다.\nprinciple of least privilege (최소 권한 원칙) 적용하면 수정할 권한을 제외한 모든 선언은 'const'를 사용해야 합니다.\n근본적인 이유는 변수를 쓸 필요가 없는 경우 동일한 코드 베이스에서 작업하는 다른 사용자가 자동으로 객체에 쓸 수 없으므로 변수에 재할당 할 필요가 있는지 여부를 고려해야 합니다.\n또한 const를 사용하면 데이터 흐름을 추론할 때 코드를 더 예측 가능하게 만들 수 있습니다.최선을 판단을 하여 해당되는 경우 팀원들과 이 문제를 상의하십시오.\n이 handbook 의 경우 대부분 let 선언을 사용합니다.\n비구조화 (Destructuring)\nTypeScript에 있는 또 다른 ECMAScript2015 기능은 비구조화입니다.전체 참조 정보는 Mozilla Developer Network의 기사를 참조하세요.이 섹션에서는 간단한 개요를 제공합니다.\n배열 비구조화 (Array destructuring)\n가장 간단한 구조 해체 방법은 배열 비구조화 할당입니다.\nlet input = [1, 2];\nlet [first, second] = input;\nconsole.log(first); // 1 출력\nconsole.log(second); // 2 출력\n\n이것은 first와 second라는 두 개의 새로운 변수를 만듭니다.\n이는 인덱스를 사용하는 것과 동일하지만 훨씬 편리합니다.\nfirst = input[0];\nsecond = input[1];\n\n비구조화는 이미 선언된 변수에서도 작동합니다.\n// 변수 교환\n[first, second] = [second, first];\n\n함수에 대한 매개 변수가 있는 경우\nfunction f([first, second]: [number, number]) {\n    console.log(first);\n    console.log(second);\n}\nf([1, 2]);\n\n... 구문을 사용하여 목록의 나머지 항목에 대한 변수를 생성할 수 있습니다.\nlet [first, ...rest] = [1, 2, 3, 4];\nconsole.log(first); // 1 출력\nconsole.log(rest); // [ 2, 3, 4 ] 출력\n\n물론 이것은 JavaScript이므로 관심이 없는 후행 요소는 무시할 수 있습니다.\nlet [first] = [1, 2, 3, 4];\nconsole.log(first); // 1 출력\n\n또는 다른 요소들 :\nlet [, second, , fourth] = [1, 2, 3, 4];\n\n객체 비구조화 (Object destructuring)\n또한 객체를 해체할 수 있습니다.\nlet o = {\n    a: \"foo\",\n    b: 12,\n    c: \"bar\"\n};\nlet { a, b } = o;\n\n이것은 o.a와 o.b에서 새로운 변수 a와 b를 생성합니다. 필요없는 경우 c를 건너뛸 수 있습니다.\n배열 비구조화처럼 선언없이 할당 수 있습니다.\n({ a, b } = { a: \"baz\", b: 101 });\n\n이 문장을 괄호로 묶어야한다는 것을 주목하십시오.JavaScript는 일반적으로 a{를 블록 시작으로 파싱합니다.\n... 구문을 사용하여 객체의 나머지 항목에 대한 변수를 만들 수 있습니다\nlet { a, ...passthrough } = o;\nlet total = passthrough.b + passthrough.c.length;\n\n프로퍼티 이름 변경 (Property renaming)\n프로퍼티의 이름 또한 다름 이름으로 지정할 수 있습니다.\nlet { a: newName1, b: newName2 } = o;\n\n문장이 혼란스러워지기 시작했습니다.\na : newName1를 \"a as newName1\"로 읽을 수 있습니다.\n방향은 왼쪽에서 오른쪽으로 사용합니다.\nlet newName1 = o.a;\nlet newName2 = o.b;\n\n혼란스럽겠지만 여기서 콜론은 타입을 나타내는 콜론은 아닙니다.형식을 지정하는 경우 전체 형식이 비구조화된 후에도 형식을 작성해야 합니다.\nlet { a, b }: { a: string, b: number } = o;\n\n기본값 (Default values)\n기본값을 사용하면 프로퍼티가 정의되지 않은 경우의 기본값을 지정할 수 있습니다.\nfunction keepWholeObject(wholeObject: { a: string, b?: number }) {\n    let { a, b = 1001 } = wholeObject;\n}\n\nkeepWholeObject 함수는 b가 정의되지 않더라도 a와 b 프로퍼티뿐만 아니라 wholeObject의 변수를 가집니다.\n함수 선언 (Function declarations)\n비구조화는 함수 선언에서도 작동합니다.간단한 예를 보겠습니다.\ntype C = { a: string, b?: number }\nfunction f({ a, b }: C): void {\n    // ...\n}\n\n그러나 매개 변수에 대해 기본값을 지정하는 것이 더 일반적이며 비구조화시 기본값을 가져오는 것은 까다로울 수 있습니다.\n우선 기본값 앞에 패턴을 두는 것을 기억해야 합니다.\nfunction f({ a, b } = { a: \"\", b: 0 }): void {\n    // ...\n}\nf(); // 좋아요, 기본값 { a: \"\", b: 0 }\n\n\n위의 코드는 나중에 handbook에서 설명할 유형 추론의 한 예제입니다.\n\n그런 다음 기본 초기화가 아닌 비구조화 프로퍼티에 대한 선택적인 프로퍼티를 기본값으로 지정한다는 것을 기억해야 합니다.c에서 b는 선택사항으로 지정되었다는 것을 기억하세요.\nfunction f({ a, b = 0 } = { a: \"\" }): void {\n    // ...\n}\nf({ a: \"yes\" }); // 좋아요, 기본값 b = 0\nf(); // 좋아요, 기본값은 { a:\"\" }이며 이 경우 기본값은 b = 0입니다.\nf({}); // 오류, 인수를 제공하려면 'a'가 필요합니다.\n\n비구조화를 조심히 사용하세요.앞의 예제에서 보여 주듯이 가장 단순한 비구조화 표현식을 제외하고는 혼란스럽습니다.이름 바꾸기 기본값 및 타입을 주석으로 써놓지 않고는 이해하기 힘든 깊은 형태를 비구조화하는 것은 특히 그렇습니다.\n비구조화 표현식은 작고 심플하게 유지하세요.\n직접 생성한 비구조화를 항상 스스로 쓸 수 있어야 합니다.\n전개 연산자 (Spread)\n전개는 비구조화의 반대입니다.배열을 다른 배열로 객체를 다른 객체로 전개하는 것을 허용합니다.\n예를 들어:\nlet first = [1, 2];\nlet second = [3, 4];\nlet bothPlus = [0, ...first, ...second, 5];\n\n이것은 bothPlus에 [0, 1, 2, 3, 4, 5]값을 부여합니다.전개는 first와 second의 얕은 복사본을 만듭니다. 그들은 전개에 의해 변하지 않습니다.\n또한 객체를 전개 할 수도 있습니다.\nlet defaults = { food: \"spicy\", price: \"$$\", ambiance: \"noisy\" };\nlet search = { ...defaults, food: \"rich\" };\n\n현재 search의 값은 { food: \"rich\", price: \"$$\", ambiance: \"noisy\" }입니다.객체의 전개는 배열의 전개보다 복잡합니다.배열은 전개를 왼쪽에서 오른쪽으로 진행하지만 결과는 여전히 객체입니다.이것은 나중에 전개한 객체의 프로퍼티가 이전에 있던 프로퍼티를 덮어씁니다.따라서 끝에 전개할 이전의 코드를 수정하면 다음과 같습니다.\nlet defaults = { food: \"spicy\", price: \"$$\", ambiance: \"noisy\" };\nlet search = { food: \"rich\", ...defaults };\n\ndefaults의 food 프로퍼티가 food: \"rich\"를 덮어쓰게 됩니다. 그러나 이것은 우리가 원한 결과가 아닙니다.'\n객체 Spread에는 몇 가지 다른 놀라운 한계가 있습니다.\n첫번째, 열거 가능 속성(own, enumerable properties) 객체에 포함됩니다.기본적으로 객체의 인스턴스를 전개할 때 메서드를 잃어버린다는 것을 의미합니다.\nclass C {\n  p = 12;\n  m() {\n  }\n}\nlet c = new C();\nlet clone = { ...c };\nclone.p; // 좋아요\nclone.m(); // 오류!\n\n두번째, Typescript 컴파일러는 일반 함수의 매개변수를 전개로 허용하지 않습니다.이 기능은 향후 버전의 언어에서 사용될 것으로 예상됩니다.\n"},"pages/Interfaces.html":{"url":"pages/Interfaces.html","title":"인터페이스","keywords":"","body":"소개 (Introduction)\nTypeScript 의 핵심 원리 중 하나는 값이 가지는 형태 에 초점을 맞추는 타입-체킹을 한다는 것입니다.이것은 때때로 \"덕 타이핑(duck typing)\" 또는 \"구조적 하위 유형화(structural subtyping)\"라고도 합니다.TypeScript 에서는 인터페이스가 이러한 타입의 이름을 지정하는 역할을 하며 코드 내에서 계약을 정의하고 프로젝트 외부에서 코드를 사용하는 계약을 정의하는 강력한 방법입니다.\n첫번째 인터페이스 (Our First Interface)\n인터페이스의 작동 방식을 확인하는 가장 쉬운 방법은 간단한 예를 들어 시작하는 것입니다:\nfunction printLabel(labelledObj: { label: string }) {\n  console.log(labelledObj.label);\n}\n\nlet myObj = { size: 10, label: \"Size 10 Object\" };\nprintLabel(myObj);\n\n타입-체커는 printLabel에 대한 호출을 확인합니다.PrintLabel 함수에는 객체를 전달하는 데 필요한 단일 매개변수가 있으며 이는 문자열 타입의 label 프로퍼티를 가집니다.실제로 객체는 이보다 더 많은 프로퍼티를 가지고 있지만 컴파일러는 필요한 속성이 최소한 있고 필요한 타입과 일치하는지만 검사합니다.TypeScript 가 그렇게 관대하지 않은 경우도 있습니다. 이에 대해 좀 더 자세히 다룰 것입니다.\n이번에도 인터페이스를 사용하여 문자열 타입인 label 프로퍼티를 가져야 한다는 요구 사항을 설명하는 동일한 예제를 다시 작성할 수 있습니다:\ninterface LabelledValue {\n  label: string;\n}\n\nfunction printLabel(labelledObj: LabelledValue) {\n  console.log(labelledObj.label);\n}\n\nlet myObj = { size: 10, label: \"Size 10 Object\" };\nprintLabel(myObj);\n\n인터페이스 LabelledValue은 이전 예제의 요구 사항을 설명하는 데 사용할 수 있는 이름입니다.여전히 label이라는 문자열 타입의 단일 프로퍼티가 있습니다.printLabel에 전달하는 객체가 다른 언어처럼 이 인터페이스를 구현한다고 명시적으로 말할 필요가 없었습니다.여기서는 중요한 형태일 뿐입니다. 함수로 전달되는 객체가 나열된 요구 사항을 충족하는 경우 허용됩니다.\n타입-체커에서는 이러한 프로퍼티가 순서대로 제공될 것을 요구하지 않으며 다만 인터페이스에 필요한 속성이 있고 필요한 타입만 필요하다는 점을 지적하는 것이 중요합니다.\n선택적 프로퍼티 (Optional Properties)\n인터페이스의 모든 프로퍼티가 필수로 필요할 수는 없습니다.어떤 것들은 특정한 조건 하에 존재하거나 아예 존재하지 않을 수도 있습니다.이러한 선택적 프로퍼티는 프로퍼티 중에서 일부만 채워진 객체를 함수에 전달하는 \"옵션 백(option bags)\"과 같은 패턴을 생성할 때 많이 사용됩니다.\n다음은 이 패턴의 예입니다:\ninterface SquareConfig {\n  color?: string;\n  width?: number;\n}\n\nfunction createSquare(config: SquareConfig): { color: string; area: number } {\n  let newSquare = { color: \"white\", area: 100 };\n  if (config.color) {\n    newSquare.color = config.color;\n  }\n  if (config.width) {\n    newSquare.area = config.width * config.width;\n  }\n  return newSquare;\n}\n\nlet mySquare = createSquare({ color: \"black\" });\n\n선택적 프로퍼티를 가진 인터페이스는 다른 인터페이스와 유사하게 작성되며 선언된 프로퍼티 이름 끝에 ?로 표시됩니다.\n선택적 프로퍼티의 장점은 사용 가능한 프로퍼티를 설명하는 동시에 인터페이스에 포함되지 않은 프로퍼티의 사용을 방지할 수 있다는 것입니다.\n예를 들어 createSquare에서 color 프로퍼티의 이름을 잘못 입력하면 다음과 같은 오류 메시지가 표시됩니다:\ninterface SquareConfig {\n  color?: string;\n  width?: number;\n}\n\nfunction createSquare(config: SquareConfig): { color: string; area: number } {\n  let newSquare = { color: \"white\", area: 100 };\n  if (config.color) {\n    // 오류 : 'SquareConfig' 타입에 'clor'프로퍼티가 존재하지 않습니다.\n    newSquare.color = config.clor;\n  }\n  if (config.width) {\n    newSquare.area = config.width * config.width;\n  }\n  return newSquare;\n}\n\nlet mySquare = createSquare({ color: \"black\" });\n\n읽기 전용 프로퍼티 (Readonly properties)\n일부 프로퍼티는 객체를 처음 생성할 때만 수정할 수 있어야 합니다.프로퍼티 이름 앞에 readonly을 붙여 넣어 지정할 수 있습니다:\ninterface Point {\n  readonly x: number;\n  readonly y: number;\n}\n\n객체 리터럴을 할당하여 Point를 구성 할 수 있습니다. 할당 후 x와 y는 바꿀 수 없습니다.\nlet p1: Point = { x: 10, y: 20 };\np1.x = 5; // 오류!\n\nTypeScript 에는 모든 변형 메서드가 제거된 Array와 동일한 ReadonlyArray타입이 있으므로 생성 후 배열을 변경하지 말아야 합니다.\nlet a: number[] = [1, 2, 3, 4];\nlet ro: ReadonlyArray = a;\nro[0] = 12; // 오류!\nro.push(5); // 오류!\nro.length = 100; // 오류!\na = ro; // 오류!\n\n코드의 마지막 줄에서 전체 ReadonlyArray를 일반적인 배열로 다시 할당하는 것조차도 불법임을 알 수 있습니다.그럼에도 불구하고 타입 단언(assertion)을 통해 오버라이드 할 수 있습니다.\na = ro as number[];\n\nreadonly vs const\nreadonly 을 사용할지 아니면 const 사용할지 기억할 수 있는 가장 쉬운 방법은 변수에서 사용할지 또는 프로퍼티에서 사용할지를 묻는 것입니다.변수는 const를 사용하는 반면 프로퍼티는 readonly를 사용합니다.\n프로퍼티 초과 검사 (Excess Property Checks)\n인터페이스를 사용하는 첫 번째 예에서 TypeScript 를 사용하면 { size: number; label: string; }을 { label: string; }으로만 예상하는 항목으로 전달할 수 있습니다.또한 선택적 프로퍼티에 대해서 배웠고 그것이 소위 말하는 \"옵션 백(option bags)\"을 설명할 때 어떻게 유용한지도 배웠습니다.\n그러나 두 가지를 결합하는 것은 JavaScript 에서 하고 있는 것과 같은 방식으로 자신의 무덤을 파는 것입니다.예를 들어 createSquare를 사용한 마지막 예제를 봅시다:\ninterface SquareConfig {\n  color?: string;\n  width?: number;\n}\n\nfunction createSquare(config: SquareConfig): { color: string; area: number } {\n  // ...\n}\n\nlet mySquare = createSquare({ colour: \"red\", width: 100 });\n\ncreateSquare의 인수는 color가 아닌 colour 입니다. 보통의 JavaScript 에서는 이러한 종류의 작업은 조용히 실패합니다.\nwidth 프로퍼티가 호환되고 color 프로퍼티가 없으며 특별하게 color 프로퍼티가 대수롭지 않기 때문에 이 프로그램이 올바른 타입임을 주장할 수 있습니다.\n그러나 TypeScript 는 이 코드에 버그가 있을 수 있음을 나타냅니다.객체 리터럴은 다른 변수에 할당하거나 인수로 전달할 때 특별한 처리를 받아 프로퍼티 초과 검사(Excess Property Checks) 를 거칩니다.객체 리터럴에 \"대상 타입\"에 없는 프로퍼티가 있을 경우 오류가 발생합니다.\n// 오류 : 'colour'는 'SquareConfig' 타입에서 필요하지 않습니다.\nlet mySquare = createSquare({ colour: \"red\", width: 100 });\n\n이런 검사을 하는 것은 실제로 정말 간단합니다.가장 쉬운 방법은 타입 단언(type assertion)을 사용하는 것입니다:\nlet mySquare = createSquare({ width: 100, opacity: 0.5 } as SquareConfig);\n\n하지만 객체에 특별한 방법으로 사용되는 추가 프로퍼티가 있는 것이 확실한 경우 문자열 인덱스 시그니처(string index signature)을 추가하는 것이 더 좋습니다.\nSquareConfig가 위의 타입이 포함되는 color 및 width 프로퍼티가 가질 수 있지만 또 다른 속성도 있는 경우에는 다음과 같이 정의할 수 있습니다.\ninterface SquareConfig {\n  color?: string;\n  width?: number;\n  [propName: string]: any;\n}\n\n이후에 인덱스 시그니처(index signatures)에 대해 이야기하겠지만 SquareConfig은 여러 프로퍼티들을 가질 수 있으며 color 또는 width가 아닌 다른 프로퍼티들의 타입은 문제 되지 않습니다.\n이러한 검사를 하는 마지막 방법 중 하나는 객체를 다른 변수에 할당하는 것입니다: squareOptions은 너무 프로퍼티 초과 검사를 거치지 않기 때문에 컴파일러가 오류를 제공하지 않습니다:\nlet squareOptions = { colour: \"red\", width: 100 };\nlet mySquare = createSquare(squareOptions);\n\n위와 같은 간단한 코드의 경우에는 이러한 검사를 \"회피하는\" 시도를 하지 말아야 합니다.메서드와 상태를 유지하는 더 복잡한 객체 리터럴의 경우 이러한 기법을 유지하고 싶은 마음이겠지만 대부분의 초과 프로퍼티 오류는 실제로 버그입니다.즉 옵션 백(option bags)과 같은 물건에 대해 초과 프로퍼티 검사 문제가 발생하는 경우 타입 선언 중 일부를 수정해야 할 수도 있습니다.createSquare에 color 또는 colour 프로퍼티를 모두 포함한 객체를 전달하는 것이 괜찮은 경우 squareConfig의 정의를 수정해야 합니다.\n함수 타입 (Function Types)\n인터페이스는 JavaScript 객체가 취할 수 있는 다양한 형태을 형성할 수 있습니다.프로퍼티를 가진 객체를 설명하는 것 외에도 인터페이스는 함수 타입을 형성할 수도 있습니다.\n인터페이스가 포함된 함수의 타입을 형성하기 위해 인터페이스에 호출 시그니처(call signature)을 제공합니다.이것은 매개 변수 목록과 반환 타입만 주어진 함수 선언과 같습니다. 매개 변수 목록의 각 매개 변수에는 이름과 타입이 모두 필요합니다.\ninterface SearchFunc {\n  (source: string, subString: string): boolean;\n}\n\n일단 정의되면 다른 인터페이스처럼 이 함수 타입의 인터페이스를 사용할 수 있습니다.여기서는 함수 타입의 변수를 생성하고 동일한 타입의 함수 값을 할당하는 방법을 보여줍니다.\nlet mySearch: SearchFunc;\nmySearch = function(source: string, subString: string) {\n  let result = source.search(subString);\n  return result > -1;\n};\n\n함수 타입의 타입을 검사할 때 매개 변수의 이름이 일치할 필요는 없습니다.예를 들어 다음과 같은 예를 작성할 수 있습니다:\nlet mySearch: SearchFunc;\nmySearch = function(src: string, sub: string): boolean {\n  let result = src.search(sub);\n  return result > -1;\n};\n\n함수 매개 변수는 하나씩 검사되며 각 해당 파라미터 위치의 타입을 서로 비교하며 검사합니다.타입을 지정하지 않으려는 경우 함수 값이 SearchFunc 타입의 변수에 직접 지정되므로 TypeScript 의 컨텍스트 타입(contextual typing)에 따라 인수 타입을 추론할 수 있습니다.또한 여기서 함수 표현식의 반환 타입은 반환되는 값에 의해서도 암시적으로 나타납니다(여기서는 true와 false)함수 표현식이 숫자나 문자열을 반환하는 경우 타입-체커가 반환 타입이 SearchFunc 인터페이스에 설명된 반환 타입과 일치하지 않는다는 경고했을 것입니다\nlet mySearch: SearchFunc;\nmySearch = function(src, sub) {\n  let result = src.search(sub);\n  return result > -1;\n};\n\n인덱싱 가능 타입(Indexable Types)\n함수 타입을 설명하기 위해 인터페이스를 사용하는 방법과 마찬가지로 a[10] 또는 ageMap[\"daniel\"]처럼 \"인덱스\"를 생성할 수 있는 타입을 만들 수도 있습니다.인덱싱 가능 타입에는 객체로 인덱싱 하는 데 사용할 수 있는 타입과 인덱싱 할 때 해당 반환 타입을 설명하는 인덱스 시그니처(index signature) 이 있습니다.예를 들어 보겠습니다.\ninterface StringArray {\n  [index: number]: string;\n}\n\nlet myArray: StringArray;\nmyArray = [\"Bob\", \"Fred\"];\n\nlet myStr: string = myArray[0];\n\n위에서 우리는 인덱스 시그니처(index signature)을 가진 String Array 인터페이스를 가지고 있습니다.이 인덱스 시그니처은 StringArray이 number로 인덱싱 될 때 string을 반환한다는 것을 나타냅니다.\n지원되는 인덱스 시그니처에는 문자열과 숫자의 두 가지 타입이 있습니다.두 가지 타입의 인덱서(indexer)를 모두 지원할 수 있지만 숫자(numeric) 인덱서에서 반환되는 타입은 문자열(string) 인덱서에서 반환된 타입의 하위 타입이어야 합니다.왜냐하면 number로 인덱싱을 생성하는 시점에 JavaScript 가 객체로 인덱싱하기 전에 string으로 변환하기 때문입니다.즉 100 (number)로 인덱싱하는 것은 \"100\" (string)으로 인덱싱하는 것과 동일하므로 두 가지 모두 일관성이 있어야 합니다.\nclass Animal {\n  name: string;\n}\nclass Dog extends Animal {\n  breed: string;\n}\n\n// 오류: numeric과 string으로 인덱싱하면 완전히 다른 타입의 Animal을 얻을 수 있습니다!\ninterface NotOkay {\n  [x: number]: Animal;\n  [x: string]: Dog;\n}\n\n문자열 인덱스 시그니처(index signatures)이 \"사전(dictionary)\" 패턴을 만드는 강력한 방법이지만 모든 프로퍼티가 반환 타입과 일치하도록 강요합니다.문자열 인덱스의 obj.property가 obj[\"property\"]으로도 사용할 수 있다고 선언하기 때문입니다.다음 예에서는 name의 타입이 문자열 인덱스의 타입과 일치하지 않으며 타입-체커에서 오류를 표시합니다\ninterface NumberDictionary {\n  [index: string]: number;\n  length: number; // 좋아요, length는 number입니다.\n  name: string; // 오류, 'name'의 타입이 인덱서의 하위 타입이 아닙니다.\n}\n\n마지막으로 인덱스에 할당되지 않도록 인덱스 시그니처(index signatures)을 읽기 전용(readonly)으로 만들 수 있습니다:\ninterface ReadonlyStringArray {\n  readonly [index: number]: string;\n}\nlet myArray: ReadonlyStringArray = [\"Alice\", \"Bob\"];\nmyArray[2] = \"Mallory\"; // 오류!\n\n인덱스 시그니처이 읽기 전용이므로 myArray[2]를 설정할 수 없습니다.\n클래스 타입 (Class Types)\n인터페이스 구현 (Implementing an interface)\nC# 및 Java 와 같은 언어로 인터페이스를 사용하는 가장 일반적인 방법 중 하나로 클래스가 특정 계약을 충족하도록 명시적인 강제가 TypeScript 에서도 가능하다는 것입니다.\ninterface ClockInterface {\n  currentTime: Date;\n}\n\nclass Clock implements ClockInterface {\n  currentTime: Date;\n  constructor(h: number, m: number) {}\n}\n\n또한 아래의 예제에서 setTime과 마찬가지로 클래스에 구현된 인터페이스의 메서드를 만들 수도 있습니다.\ninterface ClockInterface {\n  currentTime: Date;\n  setTime(d: Date);\n}\n\nclass Clock implements ClockInterface {\n  currentTime: Date;\n  setTime(d: Date) {\n    this.currentTime = d;\n  }\n  constructor(h: number, m: number) {}\n}\n\n인터페이스는 public 측면과 private 측면이 아닌 public 측면의 class 를 만듭니다.클래스를 사용하여 클래스 인스턴스의 private 측에 특정 타입이 있는지 검사하는 것은 금지되어 있습니다.\n클래스의 스태틱과 인스턴스의 차이점(Difference between the static and instance sides of classes)\n클래스와 인터페이스로 작업할 때 클래스에 두 가지 타입이 있음을 명심하세요: 스태틱 측면의 타입과 인스턴스 측면의 타입construct signature 으로 인터페이스를 만들고 이 인터페이스를 구현하는 클래스를 생성하려고 하면 오류가 발생할 수 있습니다:\ninterface ClockConstructor {\n  new (hour: number, minute: number);\n}\n\nclass Clock implements ClockConstructor {\n  currentTime: Date;\n  constructor(h: number, m: number) {}\n}\n\n왜냐하면 클래스가 인터페이스를 구현할 때 클래스의 인스턴스 측면만 검사되기 때문입니다.생성자는 정적인 측면이기 때문에 이 검사에 포함되지 않습니다.\n대신 클래스의 정적인 측면에서 직접 작업해야 합니다.이 예제에서는 생성자를 위한 ClockConstructor와 인스턴스 메서드를 위한 ClockInterface라는 두 개의 인터페이스를 정의합니다.편의상 전달된 타입의 인스턴스를 생성하는 createClock 생성자 함수를 정의합니다.\ninterface ClockConstructor {\n  new (hour: number, minute: number): ClockInterface;\n}\ninterface ClockInterface {\n  tick();\n}\n\nfunction createClock(\n  ctor: ClockConstructor,\n  hour: number,\n  minute: number\n): ClockInterface {\n  return new ctor(hour, minute);\n}\n\nclass DigitalClock implements ClockInterface {\n  constructor(h: number, m: number) {}\n  tick() {\n    console.log(\"beep beep\");\n  }\n}\nclass AnalogClock implements ClockInterface {\n  constructor(h: number, m: number) {}\n  tick() {\n    console.log(\"tick tock\");\n  }\n}\n\nlet digital = createClock(DigitalClock, 12, 17);\nlet analog = createClock(AnalogClock, 7, 32);\n\ncreateClock의 첫 번째 매개 변수는 createClock(AnalogClock, 7, 32)에 ClockConstructor 타입이므로 AnalogClock이 올바른 생성자 시그니처(constructor signature)을 가지고 있는지 확인합니다.\n인터페이스 확장 (Extending Interfaces)\n클래스처럼 인터페이스도 서로를 확장할 수 있습니다.이렇게 하면 한 인터페이스의 멤버를 다른 인터페이스로 복사할 수 있으므로 인터페이스를 재사용 가능한 컴포넌트로 분리하는 방법을 더 유연하게 할 수 있습니다.\ninterface Shape {\n  color: string;\n}\n\ninterface Square extends Shape {\n  sideLength: number;\n}\n\nlet square = {};\nsquare.color = \"blue\";\nsquare.sideLength = 10;\n\n여러 인터페이스를 확장하여 모든 인터페이스를 결합하여 만들 수 있습니다.\ninterface Shape {\n  color: string;\n}\n\ninterface PenStroke {\n  penWidth: number;\n}\n\ninterface Square extends Shape, PenStroke {\n  sideLength: number;\n}\n\nlet square = {};\nsquare.color = \"blue\";\nsquare.sideLength = 10;\nsquare.penWidth = 5.0;\n\n하이브리드 타입 (Hybrid Types)\n이전에 언급했듯이 인터페이스는 실제 JavaScript 에서 제공되는 풍부한 타입을 만들 수 있습니다.JavaScript 의 동적이고 유연한 특성으로 인해 위에 설명된 몇 가지 타입의 조합으로 작동하는 객체를 종종 볼 수 있습니다.\n이러한 예로는 다음과 같이 추가 프로퍼티로 함수와 객체 역할을 모두 하는 객체가 있습니다:\ninterface Counter {\n  (start: number): string;\n  interval: number;\n  reset(): void;\n}\n\nfunction getCounter(): Counter {\n  let counter = function(start: number) {};\n  counter.interval = 123;\n  counter.reset = function() {};\n  return counter;\n}\n\nlet c = getCounter();\nc(10);\nc.reset();\nc.interval = 5.0;\n\n써드-파티 JavaScript 와 상호 작용할 때 타입의 형태를 완전히 형성하려면 위와 같은 패턴을 사용해야 할 수 있습니다.\n인터페이스 확장 클래스 (Interfaces Extending Classes)\n인터페이스 타입이 클래스 타입을 확장하면 해당 클래스의 멤버들을 상속하지만 구현을 상속하지는 않습니다.이는 마치 인터페이스가 구현을 제공하지 않고 클래스의 모든 멤버를 선언한 것과 같습니다.인터페이스는 기본 클래스의 private 및 protected 멤버조차도 상속합니다.즉 private 또는 protected 멤버가 있는 클래스를 확장하는 인터페이스를 생성하면 해당 인터페이스 타입은 해당 클래스 또는 해당 클래스의 서브 클래스에서만 구현할 수 있습니다.\n이는 상속 계층이 크지만 특정 프로퍼티를 가진 서브 클래스에서만 코드가 작동하도록 지정하려는 경우에 유용합니다.서브 클래스는 기본 클래스에서 상속받는 것 외에는 관련이 없습니다.\n예를 들어:\nclass Control {\n  private state: any;\n}\n\ninterface SelectableControl extends Control {\n  select(): void;\n}\n\nclass Button extends Control implements SelectableControl {\n  select() {}\n}\n\nclass TextBox extends Control {\n  select() {}\n}\n\n// 오류: 'Image' 타입의 'state' 프로퍼티가 없습니다.\nclass Image implements SelectableControl {\n  select() {}\n}\n\nclass Location {}\n\n위의 예제에서 SelectableControl에는 Private state 프로퍼티를 포함한 Control의 모든 멤버가 포함되어 있습니다.state는 private 멤버이기 때문에 Control의 자식만 SelectableControl을 구현할 수 있습니다.왜냐하면 Control의 자식들만이 같은 선언에서 시작된 state private 멤버를 가지기 때문입니다.이것은 private 멤버들이 호환 가능해야 합니다.\nControl 클래스 내에서 SelectableControl의 인스턴스를 통해 state private 멤버에 접근할 수 있습니다.실제로 SelectableControl은 알려진 대로 select 메서드를 가진 Control과 같은 역할을 합니다.Button과 TextBox 클래스는 SelectableControl의 하위 타입입니다(왜냐하면 둘 다 Control을 상속받으며 select 메서드를 가지기 때문입니다).그러나 Image 클래스와 Location 클래스는 그렇지 않습니다.\n"},"pages/Classes.html":{"url":"pages/Classes.html","title":"클래스","keywords":"","body":"소개 (Introduction)\n전통적인 JavaScript는 재사용 가능한 컴포넌트를 만들기 위해 함수와 프로토 타입 기반의 상속을 사용하지만 클래스가 함수를 상속하고 객체가 이러한 클래스에서 구축되는 객체 지향 접근 방식에 익숙하지 않은 개발자들에게는 다소 어색함을 느낄 수 있습니다.ECMAScript6로도 알려진 ECMAScript 2015년을 시작으로 JavaScript 개발자는 이 객체 지향 클래스 기반 접근 방식을 사용하여 응용 프로그램을 구축 할 수 있습니다.TypeScript에서는 개발자가 이 기술을 사용하고 다음 JavaScript 버전을 기다리지 않고도 모든 메이저 브라우저와 플랫폼에서 작동하는 JavaScript로 컴파일 할 수 있습니다.\n클래스 (Classes)\n간단한 클래스 기반 예제를 살펴보겠습니다:\nclass Greeter {\n    greeting: string;\n    constructor(message: string) {\n        this.greeting = message;\n    }\n    greet() {\n        return \"Hello, \" + this.greeting;\n    }\n}\n\nlet greeter = new Greeter(\"world\");\n\n이전에 C# 또는 Java를 사용한 적이 있는 경우 구문이 익숙하게 보여야 합니다.새로운 클래스인 Greeter을 선언합니다.\n이 클래스에는 3개의 멤버가 있습니다: greeting 프로퍼티와 생성자 그리고 greet 메서드가 있습니다.\n클래스의 멤버 중 하나를 참조할 때 클래스에서 this를 앞에 접두어로 붙입니다.\n이것은 멤버에 접근하는 것을 뜻합니다.\n마지막 줄에서는 new를 사용하여 Greeter 클래스의 인스턴스를 만듭니다.이것은 이전에 정의한 생성자를 호출하여 Greeter 형태의 새 객체를 만들고 생성자를 실행하여 이를 초기화합니다.\n상속 (Inheritance)\nTypeScript에서는 일반적인 객체 지향 패턴을 사용할 수 있습니다.클래스 기반 프로그래밍에서 가장 기본적인 패턴 중 하나는 상속을 사용하여 기존 클래스를 확장하여 새로운 클래스를 생성할 수 있다는 것입니다.\n예제를 살펴보겠습니다:\nclass Animal {\n    move(distanceInMeters: number = 0) {\n        console.log(`Animal moved ${distanceInMeters}m.`);\n    }\n}\n\nclass Dog extends Animal {\n    bark() {\n        console.log('Woof! Woof!');\n    }\n}\n\nconst dog = new Dog();\ndog.bark();\ndog.move(10);\ndog.bark();\n\n이 예제는 가장 기본적인 상속 기능을 보여줍니다: 클래스는 기본 클래스에서 속성과 메서드를 상속받습니다.여기서 Dog는 extends 키워드를 사용하여 Animal 기본 클래스에서 유래된 파생 클래스입니다.파생 클래스는 종종 하위 클래스(subclasses) 라고 하며 기본 클래스는 슈퍼 클래스(superclasses) 라고도 합니다.\nDog는 Animal로부터 기능을 확장시키기 때문에 bark()와 move() 둘 다 할 수 있는 Dog의 인스턴스를 만들 수 있었습니다.\n이제 좀 더 복잡한 예제를 살펴보겠습니다.\nclass Animal {\n    name: string;\n    constructor(theName: string) { this.name = theName; }\n    move(distanceInMeters: number = 0) {\n        console.log(`${this.name} moved ${distanceInMeters}m.`);\n    }\n}\n\nclass Snake extends Animal {\n    constructor(name: string) { super(name); }\n    move(distanceInMeters = 5) {\n        console.log(\"Slithering...\");\n        super.move(distanceInMeters);\n    }\n}\n\nclass Horse extends Animal {\n    constructor(name: string) { super(name); }\n    move(distanceInMeters = 45) {\n        console.log(\"Galloping...\");\n        super.move(distanceInMeters);\n    }\n}\n\nlet sam = new Snake(\"Sammy the Python\");\nlet tom: Animal = new Horse(\"Tommy the Palomino\");\n\nsam.move();\ntom.move(34);\n\n이 예제는 앞서 언급하지 않은 몇 가지 다른 기능을 다룹니다.이번에도 Animal의 새로운 하위 클래스인 Horse과 Snake을 만드는 extends 키워드가 등장합니다.\n이전 예제와의 한 가지 다른 점은 생성자 함수를 포함하는 각 파생 클래스가 기본 클래스의 생성자를 실행할 super()를 호출해야한다는 것입니다.게다가 생성자 내에서 this에 있는 프로퍼티에 접근하기 전에 항상 super()를 호출해야 합니다.이것은 TypeScript가 적용할 중요한 규칙입니다.\n또한 이 예제에서는 기본 클래스의 메서드를 하위 클래스에 특화된 메서드를 오버라이드 하는 방법도 보여 줍니다.\n여기에서 Snake와 Horse는 Animal의 move를 오버라이드하고 각 클래스에 고유한 기능을 부여하는 move 메서드를 만듭니다.\ntom은 Animal로 선언되었지만 Horse의 값을 가지므로 tom.move(34)를 호출하면 Horse의 오버라이딩 메서드가 호출됩니다:\nSlithering...\nSammy the Python moved 5m.\nGalloping...\nTommy the Palomino moved 34m.\n\nPublic, private, 그리고 protected 지정자 (Public, private, and protected modifiers)\n기본적인 Public (Public by default)\n예를 들어 프로그램을 통해 선언된 멤버들에 자유롭게 접근할 수 있었습니다.\n다른 언어의 클래스에 익숙하다면 위의 예제에서 public을 사용하지 않아도 된다는 사실을 알았을 것입니다.예를 들어 C#의 경우 각 멤버를 public으로 표시하도록 명시해야합니다.\nTypeScript에서는 기본적으로 각 멤버가 public입니다.\n그럼에도 불구하고 public를 멤버를 명시적으로 표시할 수 있습니다.이전 섹션의 Animal 클래스를 다음과 같이 작성할 수 있었습니다:\nclass Animal {\n    public name: string;\n    public constructor(theName: string) { this.name = theName; }\n    public move(distanceInMeters: number) {\n        console.log(`${this.name} moved ${distanceInMeters}m.`);\n    }\n}\n\nprivate 이해하기 (Understanding private)\n멤버가 private으로 표시되면 그 멤버를 포함하는 클래스의 외부에서는 접근할 수 없습니다. 예 :\nclass Animal {\n    private name: string;\n    constructor(theName: string) { this.name = theName; }\n}\n\nnew Animal(\"Cat\").name; // 오류: 'name'은 private이다;\n\nTypeScript는 구조적인 타입의 시스템입니다.두 개의 다른 타입을 비교할 때 그것들이 어디서 왔는지에 관계없이 모든 멤버의 타입이 호환 가능하다면 그 타입 자체가 호환성(compatible)이 있다고 말합니다.\n그러나 private 및 protected멤버가 있는 타입을 비교할 때 이러한 타입들은 다르게 처리합니다.\n호환성(compatible)이 있는 것으로 판단되는 두 가지 타입 중 private멤버가 있는 경우 다른 멤버는 동일한 선언에서 유래된 private멤버가 있어야 합니다.이것은 protected멤버에도 적용됩니다.\n실제로 이러한 기능이 어떻게 작동하는지를 더 잘 알아보기 위한 예를 살펴보겠습니다:\nclass Animal {\n    private name: string;\n    constructor(theName: string) { this.name = theName; }\n}\n\nclass Rhino extends Animal {\n    constructor() { super(\"Rhino\"); }\n}\n\nclass Employee {\n    private name: string;\n    constructor(theName: string) { this.name = theName; }\n}\n\nlet animal = new Animal(\"Goat\");\nlet rhino = new Rhino();\nlet employee = new Employee(\"Bob\");\n\nanimal = rhino;\nanimal = employee; // 오류: 'Animal'과 'Employee'는 호환되지 않습니다.\n\n이 예제에서는 Animal과 Rhino가 있습니다. Rhino는 Animal의 하위 클래스입니다.또한 구체적으로 Animal과 같아 보이는 Employee라는 새로운 클래스를 가지고 있습니다.이러한 클래스들의 인스턴스들을 만들고 서로를 할당하여 어떠한 일이 발생하는지 봅시다.\nAnimal과 Rhino는 Animal의 private name: string 선언으로부터 private의 형태를 공유하기 때문에 호환됩니다.그러나 Employee의 경우는 그렇지 않습니다.\nEmployee를 Animal에 할당하려고 할 때 이 타입들은 호환되지 않는다는 오류가 발생합니다.Employee도 name이라는 private 멤버가 있지만 Animal에서 선언한 것이 아닙니다.\nprotected 이해하기 (Understanding protected)\nprotected 지정자는 private 지정자와 매우 유사하게 동작합니다.단 protected 멤버도 선언된 파생 클래스의 인스턴스에서 접근할 수 있습니다.  \n예를 들어\nclass Person {\n    protected name: string;\n    constructor(name: string) { this.name = name; }\n}\n\nclass Employee extends Person {\n    private department: string;\n\n    constructor(name: string, department: string) {\n        super(name);\n        this.department = department;\n    }\n\n    public getElevatorPitch() {\n        return `Hello, my name is ${this.name} and I work in ${this.department}.`;\n    }\n}\n\nlet howard = new Employee(\"Howard\", \"Sales\");\nconsole.log(howard.getElevatorPitch());\nconsole.log(howard.name); // 오류\n\nPerson의 외부에서 name을 사용할 수는 없지만 Employee는 Person으로부터 파생되기 때문에 Employee의 인스턴스 메서드 내에서 여전히 사용할 수 있습니다.\n생성자 또한 protected로 표시될 수도 있습니다.즉 클래스를 포함하는 클래스 외부에서 클래스를 인스턴스화할 수는 없지만 확장될 수는 있습니다.\n예를 들어\nclass Person {\n    protected name: string;\n    protected constructor(theName: string) { this.name = theName; }\n}\n\n// Employee는 Person을 확장할 수 있습니다\nclass Employee extends Person {\n    private department: string;\n\n    constructor(name: string, department: string) {\n        super(name);\n        this.department = department;\n    }\n\n    public getElevatorPitch() {\n        return `Hello, my name is ${this.name} and I work in ${this.department}.`;\n    }\n}\n\nlet howard = new Employee(\"Howard\", \"Sales\");\nlet john = new Person(\"John\"); // 오류: 'Person'의 생성자는 protected입니다.\n\nReadonly 지정자 (Readonly modifier)\nreadonly 키워드를 사용하여 프로퍼티들을 읽기 전용으로 만들 수 있습니다.\n읽기 전용 프로퍼티들은 선언 또는 생성자에서 초기화해야합니다.\nclass Octopus {\n    readonly name: string;\n    readonly numberOfLegs: number = 8;\n    constructor (theName: string) {\n        this.name = theName;\n    }\n}\nlet dad = new Octopus(\"Man with the 8 strong legs\");\ndad.name = \"Man with the 3-piece suit\"; // 오류! name은 readonly입니다.\n\n매개변수 프로퍼티 (Parameter properties)\n마지막 예제의 Octopus 클래스에서 readonly 멤버 name과 생성자 매개변수 theName을 선언했습니다.그 다음 바로 name을 theName으로 설정했습니다.\n이것은 매우 일반적인 방법입니다.매개변수 프로퍼티(Parameter properties) 를 사용하면 한 곳에서 멤버를 생성하고 초기화할 수 있습니다.다음은 매개 변수 프로퍼티를 사용하여 이전에 Octopus 클래스를 추가적으로 수정합니다:\nclass Octopus {\n    readonly numberOfLegs: number = 8;\n    constructor(readonly name: string) {\n    }\n}\n\ntheName을 어떻게 삭제했는지 확인하고 생성자에서 readonly name : string 매개 변수를 사용해 멤버 name을 생성하고 초기화할 수 있습니다.\n선언과 할당을 하나의 장소로 통합했습니다.\n매개변수 프로퍼티는 접근 지정자(accessibility modifier) 또는 readonly 또는 둘 모두로 생성자 매개변수를 접두어로 붙여 선언합니다.매개 변수 프로퍼티에 private을 사용하면 private 멤버가 선언되고 초기화됩니다.마찬가지로 public와 protected 그리고 readonly도 마찬가지입니다.\n접근자 (Accessors)\nTypeScript는 객체의 멤버에 대한 접근을 인터셉트하는 방법으로 getters/setters를 지원합니다.이것을 통해 각 객체에서 멤버에 접근하는 방법을 세부적으로 제어할 수 있습니다.\n간단한 클래스에 get과 set을 사용하도록 변환해봅시다.\n먼저 getter와 setter가 없는 예제부터 시작합시다.\nclass Employee {\n    fullName: string;\n}\n\nlet employee = new Employee();\nemployee.fullName = \"Bob Smith\";\nif (employee.fullName) {\n    console.log(employee.fullName);\n}\n\n사람들이 임의로 fullName을 직접 설정하는 것은 매우 편리하지만 기분 내키는 대로 이름을 바꿀 수 있다면 문제를 일으킬 수 있습니다\n이 버전에서는 employee를 수정할 수 있도록 하기 전에 사용자가 passcode를 사용할 수 있는지 확인합니다.이를 위해 passcode를 확인할 fullName에 대한 직접적인 권한을 set으로 교체합니다.앞의 예제가 계속해서 원활하게 작동하도록 하기 위해 그에 상응하는 get을 추가합니다.\nlet passcode = \"secret passcode\";\n\nclass Employee {\n    private _fullName: string;\n\n    get fullName(): string {\n        return this._fullName;\n    }\n\n    set fullName(newName: string) {\n        if (passcode && passcode == \"secret passcode\") {\n            this._fullName = newName;\n        }\n        else {\n            console.log(\"오류 : employee의 무단 업데이트!\");\n        }\n    }\n}\n\nlet employee = new Employee();\nemployee.fullName = \"Bob Smith\";\nif (employee.fullName) {\n    console.log(employee.fullName);\n}\n\n접근자가 passcode를 확인하고 있다는 것을 입증하기 위해 passcode를 수정하고 passcode가 일치하지 않을 경우 employee에게 업데이트 권한이 없다는 경고 메시지를 받을 수 있습니다.\n접근자에 대해 알아야 할 몇 가지 주의사항:\n첫째, 접근자를 사용하려면 ECMAScript5 이상을 출력하도록 컴파일러를 설정해야 합니다.\nECMAScript3 다운그레이드는 지원되지 않습니다.\n둘째, get과 set을 가진 접근자는 자동적으로 readonly로 추론됩니다.이것은 코드에서 .d.ts 파일을 생성할 때 유용합니다. 왜냐하면 프로퍼티를 변경할 수 없다는 것을 알 수 있기 때문입니다.\n정적 프로퍼티 (Static Properties)\n지금까지는 인스턴스의 클래스 멤버들에 대해서만 이야기했습니다.인스턴스는 인스턴스화될 때 객체에서 나타납니다.또한 인스턴스가 아닌 클래스 자체에 볼 수 있는 스태틱 멤버도 생성할 수 있습니다.\n이 예제에서는 모든 grid의 일반적인 값이기 때문에 origin에 스태틱을 사용합니다.각 인스턴스는 클래스의 이름을 미리 정의하여 이 값에 접근합니다.인스턴스의 접근자 앞에 this. 를 추가하는 것과 비슷하게 스태틱 접근자 앞에 Grid를 추가합니다.\nclass Grid {\n    static origin = {x: 0, y: 0};\n    calculateDistanceFromOrigin(point: {x: number; y: number;}) {\n        let xDist = (point.x - Grid.origin.x);\n        let yDist = (point.y - Grid.origin.y);\n        return Math.sqrt(xDist * xDist + yDist * yDist) / this.scale;\n    }\n    constructor (public scale: number) { }\n}\n\nlet grid1 = new Grid(1.0);  // 1x scale\nlet grid2 = new Grid(5.0);  // 5x scale\n\nconsole.log(grid1.calculateDistanceFromOrigin({x: 10, y: 10}));\nconsole.log(grid2.calculateDistanceFromOrigin({x: 10, y: 10}));\n\n추상 클래스 (Abstract Classes)\n추상 클래스는 다른 클래스가 파생될 수 있는 기본 클래스입니다.추상 클래스는 직접적으로 인스턴스화할 수 없습니다.인터페이스와 달리 추상 클래스는 클래스의 멤버에 대한 구현 세부 정보를 포함할 수 있습니다.abstract 키워드는 추상 클래스뿐만 아니라 추상 클래스 내의 추상 메서드를 정의하는 데 사용됩니다.\nabstract class Animal {\n    abstract makeSound(): void;\n    move(): void {\n        console.log(\"roaming the earth...\");\n    }\n}\n\nabstract으로 표시된 추상 클래스 내의 메서드는 구현을 포함하지 않으므로 파생된 클래스에서 구현해야 합니다.추상 메서드는 인터페이스 메서드와 유사한 구문을 사용합니다.둘 다 메서드 본문을 포함하지 않고 메서드를 정의합니다.그러나 추상 메서드는 abstract 키워드를 포함해야 하며 선택적으로 접근 지정자를 포함할 수 있습니다.\nabstract class Department {\n\n    constructor(public name: string) {\n    }\n\n    printName(): void {\n        console.log(\"Department name: \" + this.name);\n    }\n\n    abstract printMeeting(): void; // 파생된 클래스에서 구현해야 합니다.\n}\n\nclass AccountingDepartment extends Department {\n\n    constructor() {\n        super(\"Accounting and Auditing\"); // 파생된 클래스의 생성자는 super()를 호출해야합니다.\n    }\n\n    printMeeting(): void {\n        console.log(\"The Accounting Department meets each Monday at 10am.\");\n    }\n\n    generateReports(): void {\n        console.log(\"Generating accounting reports...\");\n    }\n}\n\nlet department: Department; // 좋아요: abstract 타입에 대한 참조를 만듭니다.\ndepartment = new Department(); // 오류: 추상 클래스의 인스턴스를 생성할 수 없습니다.\ndepartment = new AccountingDepartment(); // 좋아요: 추상적이지 않은 하위 클래스를 생성하고 할당합니다.\ndepartment.printName();\ndepartment.printMeeting();\ndepartment.generateReports(); // 오류: abstract 타입으로 선언된 메서드가 존재하지 않습니다.\n\n고급 기법 (Advanced Techniques)\n생성자 함수 (Constructor functions)\nTypeScript에서 클래스를 선언하면 실제로 여러 선언이 동시에 생성됩니다.\n첫 번째 클래스의 인스턴스 타입입니다.\nclass Greeter {\n    greeting: string;\n    constructor(message: string) {\n        this.greeting = message;\n    }\n    greet() {\n        return \"Hello, \" + this.greeting;\n    }\n}\n\nlet greeter: Greeter;\ngreeter = new Greeter(\"world\");\nconsole.log(greeter.greet());\n\n여기서 let greeter: Greeter라고 할 때 Greeter 클래스의 인스턴스 타입으로 Greeter를 사용합니다.이것는 다른 객체 지향 언어를 사용하는 개발자에게는 거의 두 번째 특성입니다.\n또한 생성자 함수라고 부르는 또 다른 값을 생성하고 있습니다.\n이것은 클래스의 인스턴스를 new 할 때 호출되는 함수입니다.\n실제로 이 과정이 어떻게 진행되고 있는지 확인하기 위해 위의 예제에서 생성된 JavaScript를 살펴보겠습니다:\nlet Greeter = (function () {\n    function Greeter(message) {\n        this.greeting = message;\n    }\n    Greeter.prototype.greet = function () {\n        return \"Hello, \" + this.greeting;\n    };\n    return Greeter;\n})();\n\nlet greeter;\ngreeter = new Greeter(\"world\");\nconsole.log(greeter.greet());\n\n여기서 let Greeter는 생성자 함수를 할당 받게 될 것입니다.new를 호출하고 이 함수를 실행하면 클래스의 인스턴스를 얻습니다.생성자 함수에는 클래스의 모든 스태틱 멤버 또한 포함됩니다.각각의 클래스를 생각하는 또 다른 방법은 인스턴스 측면과 스태틱 측면이 있다는 것입니다.\n이 차이를 보여 주기 위해 예제를 약간 수정해 보겠습니다:\nclass Greeter {\n    static standardGreeting = \"Hello, there\";\n    greeting: string;\n    greet() {\n        if (this.greeting) {\n            return \"Hello, \" + this.greeting;\n        }\n        else {\n            return Greeter.standardGreeting;\n        }\n    }\n}\n\nlet greeter1: Greeter;\ngreeter1 = new Greeter();\nconsole.log(greeter1.greet());\n\nlet greeterMaker: typeof Greeter = Greeter;\ngreeterMaker.standardGreeting = \"Hey there!\";\n\nlet greeter2: Greeter = new greeterMaker();\nconsole.log(greeter2.greet());\n\n이 예제에서 greeter1은 이전과 비슷하게 작동합니다.Greeter 클래스를 인스턴스화하고 이 객체를 사용합니다.이것은 전에 본 적이 있는 것입니다.\n그런 다음 그 클래스를 직접 사용합니다.여기서 greeterMaker라는 새로운 변수를 만듭니다.이 변수는 클래스 자체를 유지하거나 생성자 함수라고 하는 또 다른 방법으로 설명합니다.  \n여기서는 typeof Greeter를 사용합니다.즉 \"인스턴스 타입이 아닌 \"Greeter 클래스 자체의 타입을 제공합니다\".또는 더 정확하게 생성자 함수의 타입인 \"Greeter라는 symbol 타입을 제공합니다\".이 타입에는 Greeter 클래스의 인스턴스를 생성하는 생성자와 함께 Greeter의 모든 스태틱 멤버가 포함됩니다.greeterMaker에 new를 사용하는 것을 보여 주며 Greeter의 새로운 인스턴스를 생성하고 이전과 같이 호출합니다.\n클래스를 인터페이스로 사용하기 (Using a class as an interface)\n앞서 언급한 것처럼 클래스 선언은 두 가지를 생성합니다: 클래스의 인스턴스를 나타내는 타입과 생성자 함수클래스는 타입을 작성하기 때문에 인터페이스를 사용할 수 있는 동일한 위치에서 타입을 사용할 수 있습니다.\nclass Point {\n    x: number;\n    y: number;\n}\n\ninterface Point3d extends Point {\n    z: number;\n}\n\nlet point3d: Point3d = {x: 1, y: 2, z: 3};\n\n"},"pages/Functions.html":{"url":"pages/Functions.html","title":"함수","keywords":"","body":"소개 (Introduction)\n함수는 JavaScript의 모든 애플리케이션을 구성하는 기본 요소입니다.클래스는 추상화 계층, 클래스, 정보 은닉 및 모듈을 구축하는 방법입니다.TypeScript에서는 클래스와 네임 스페이스 그리고 모듈이 있지만 함수는 그럼에도 불구하고 작업 방법을 설명하는 데 중요한 역할을 합니다.또한 TypeScript는 표준 JavaScript 기능에 몇가지 새로운 기능을 추가하여 작업을 더 쉽게 해 줍니다.\n함수 (Functions)\nJavaScript와 마찬가지로 TypeScript 함수는 기명 함수 또는 익명 함수로 만들 수 있습니다.이를 통해 API의 함수 목록을 작성하든 다른 함수에 전달할 일회성 함수이든 애플리케이션에 가장 적합한 접근 방법을 선택할 수 있습니다.\n이 두가지 접근 방식이 JavaScript에서 어떻게 보이는지 빠르게 요약하면:\n// 기명 함수\nfunction add(x, y) {\n    return x + y;\n}\n\n// 익명 함수\nlet myAdd = function(x, y) { return x + y; };\n\nJavaScript에서와 마찬가지로 함수는 함수 본문 외부의 변수를 참조할 수 있습니다.그렇게 할 때 이러한 변수들을 capture라고 말합니다.이 기법의 사용 방법과 사용할 때의 절충 사항을 이해하는 것은 이번 장의 범위를 벗어나지만캡처의 메커니즘이 JavaScript와 TypeScript에 얼마나 중요한 부분인지 확실히 이해해야 합니다.\nlet z = 100;\n\nfunction addToZ(x, y) {\n    return x + y + z;\n}\n\n함수의 타입 (Function Types)\n함수 작성하기 (Typing the function)\n앞에서 살펴본 간단한 예제에 타입을 추가해보겠습니다.\nfunction add(x: number, y: number): number {\n    return x + y;\n}\n\nlet myAdd = function(x: number, y: number): number { return x + y; };\n\n각 매개변수에 타입을 추가 한 다음 함수 자체에 타입을 추가하여 반환 타입을 추가할 수 있습니다.TypeScript는 리턴문를 보고 반환 타입을 파악할 수 있기 때문에 대부분 선택적으로 반환 타입을 생략할 수 있습니다.\n함수 타입 작성하기 (Writing the function type)\n이제 함수를 작성했으므로 함수 타입의 각 부분을 살펴보면서 함수의 전체 타입을 작성해보겠습니다.\nlet myAdd: (x: number, y: number) => number =\n    function(x: number, y: number): number { return x + y; };\n\n함수의 타입은 두개의 파트로 나뉩니다: 인수의 타입과 반환 타입.전체 함수 타입을 작성할 때 두 파트가 모두 필요합니다.매개변수 타입과 같이 매개변수 목록을 기록하여 각 매개변수에 이름과 타입을 지정합니다.이 이름은 가독성을 돕기 위한 것입니다.\n위의 코드를 다음과 같이 작성할 수 있습니다:\nlet myAdd: (baseValue: number, increment: number) => number =\n    function(x: number, y: number): number { return x + y; };\n\n매개변수 타입이 정렬되어 있는 한 함수의 타입에 매개변수를 제공하는 이름에 관계 없이 매개변수 타입이 유효한 타입으로 간주됩니다.\n두 번째 파트는 반환 타입입니다.매개변수와 반환 타입 사이에 굵은 화살표(=>)를 사용하여 반환 타입을 명확하게 합니다.앞서 언급한 것처럼 이것은 함수 타입의 필수적인 부분이므로 함수가 값을 반환하지 않는 경우에는 반환 값을 남겨 두지 않고 void를 사용합니다.\n주의사항, 매개변수와 반환 타입만 함수 타입을 구성합니다.캡처된 변수는 타입에 반영되지 않습니다.실제로 캡처된 변수는 함수의 \"숨겨진 상태\"의 일부이며 해당 API를 구성하지 않습니다.\n타입 추론 (Inferring the types)\n예를 들어 TypeScript 컴파일러는 한쪽에는 타입이 있지만 다른 한쪽에 타입이 없는 경우 그 타입을 이해할 수 없다는 것을 알게 됩니다:\n// myAdd는 완벽하게 함수 타입을 가지고 있습니다.\nlet myAdd = function(x: number, y: number): number { return  x + y; };\n\n// 매개변수 'x'와 'y'에는 number 타입이 있습니다.\nlet myAdd: (baseValue: number, increment: number) => number =\n    function(x, y) { return x + y; };\n\n이것을 타입 추론의 한 종류인 \"상황적 타이핑(Contextual Typing)\"이라고 합니다.\n이를 통해 프로그램을 계속 유지하는 데 드는 노력을 줄일 수 있습니다.\n선택적 매개변수와 기본 매개변수 (Optional and Default Parameters)\nTypeScript에서는 모든 매개변수가 함수에 필요하다고 가정합니다.null 또는 undefined가 주어질 수 없다는 것을 의미하는 것이 아니라 함수가 호출될 때 컴파일러가 각 매개변수에 값을 제공했는지 확인한다는 것입니다.또한 컴파일러는 이러한 매개변수들이 함수로 전달되는 유일한 매개변수라고 가정합니다.간단히 말해서 함수에 주어진 인수의 수는 그 함수에서 기대하는 매개변수의 수와 일치해야 합니다.\nfunction buildName(firstName: string, lastName: string) {\n    return firstName + \" \" + lastName;\n}\n\nlet result1 = buildName(\"Bob\");                  // 오류, 너무 적은 매개변수\nlet result2 = buildName(\"Bob\", \"Adams\", \"Sr.\");  // 오류, 너무 많은 매개변수\nlet result3 = buildName(\"Bob\", \"Adams\");         // 아, 딱 맞습니다\n\nJavaScript에서 모든 매개변수는 선택 사항이며 매개변수를 원하는 대로 사용하지 않을 수 있습니다.그렇게 되면 그 매개변수들의 값은 undefined입니다.\nTypeScript에서 선택적인 매개변수를 사용하려면 선택적으로 사용하려는 매개변수의 끝에 ?를 추가하세요.\n예를 들어 위에서 사용한 lastName 매개변수를 선택적으로 사용할 수 있도록 합니다:\nfunction buildName(firstName: string, lastName?: string) {\n    if (lastName)\n        return firstName + \" \" + lastName;\n    else\n        return firstName;\n}\n\nlet result1 = buildName(\"Bob\");                  // 올바르게 작동합니다\nlet result2 = buildName(\"Bob\", \"Adams\", \"Sr.\");  // 오류, 너무 많은 매개변수\nlet result3 = buildName(\"Bob\", \"Adams\");         // 아, 딱 맞습니다\n\n모든 선택적 매개변수는 필수 매개변수를 따라와야 합니다.last name 대신 first name을 선택적 매개변수로 만들고 싶다면 함수의 매개변수 순서를 변경해야 합니다.즉 목록의 first name을 마지막에 넣어야합니다.\nTypeScript에서 사용자가 매개변수를 제공하지 않거나 사용자가 대신 undefined를 전달하더라도 매개변수가에 할당되는 값을 설정할 수 있습니다.이것을 기본 매개변수(default-initialized parameters)라고 합니다.\n앞의 예제를 따라 last name의 기본값을 \"Smith\"로 설정해 보겠습니다.\nfunction buildName(firstName: string, lastName = \"Smith\") {\n    return firstName + \" \" + lastName;\n}\n\nlet result1 = buildName(\"Bob\");                  // 올바르게 작동하며 \"Bob Smith\"를 반환합니다\nlet result2 = buildName(\"Bob\", undefined);       // 여전히 작동하며 \"Bob Smith\"를 반환합니다.\nlet result3 = buildName(\"Bob\", \"Adams\", \"Sr.\");  // 오류, 너무 많은 매개변수\nlet result4 = buildName(\"Bob\", \"Adams\");         // 아, 딱 맞습니다\n\n필수 매개변수의 뒤에 오는 기본 매개변수는 선택적 매개변수로 취급되어 함수를 호출할 때 선택적 매개변수처럼 생략할 수 있습니다.이것은 선택적 매개변수와 후행 기본 매개변수가 해당 타입의 공통점을 공유한다는 것을 의미하므로  \n둘 다\nfunction buildName(firstName: string, lastName?: string) {\n    // ...\n}\n\n그리고\nfunction buildName(firstName: string, lastName = \"Smith\") {\n    // ...\n}\n\n(firstName: string, lastName?: string) => string 동일한 타입을 공유합니다.lastName의 기본 값은 타입에서 사라지고 매개변수가 선택 사항이라는 사실만 남겨졌습니다.\n일반 선택적 매개변수와 달리 기본 매개변수는 필수 매개변수 뒤에 나올 필요가 없습니다.기본 매개변수가 필수 매개변수 앞에 오는 경우 사용자는 명시적으로 undefined를 전달하여 기본 초기화된 값을 가져와야 합니다.\n예를 들어 firstName에 기본 초기화만 있는 마지막 예제를 작성할 수 있습니다:\nfunction buildName(firstName = \"Will\", lastName: string) {\n    return firstName + \" \" + lastName;\n}\n\nlet result1 = buildName(\"Bob\");                  // 오류, 너무 적은 매개변수\nlet result2 = buildName(\"Bob\", \"Adams\", \"Sr.\");  // 오류, 너무 많은 매개변수\nlet result3 = buildName(\"Bob\", \"Adams\");         // 좋아요 \"Bob Adams\"를 반환합니다\nlet result4 = buildName(undefined, \"Adams\");     // 좋아요 \"Will Adams\"를 반환합니다\n\n나머지 매개변수 (Rest Parameters)\n필수 매개변수와 선택적 매개변수 그리고 기본 매개변수 모두 공통점이 하나 있습니다: 한 번에 하나의 매개변수에 대해 이야기합니다.때로는 여러 매개변수를 그룹으로 사용하거나 함수가 마지막으로 가져올 매개변수의 수를 모를 수 있습니다.JavaScript에서는 모든 함수 본문에서 볼 수 있는 arguments를 사용하여 인수를 직접 사용할 수 있습니다.\nTypeScript에서는 다음과 같은 인수를 변수로 함께 모을수 있습니다:\nfunction buildName(firstName: string, ...restOfName: string[]) {\n    return firstName + \" \" + restOfName.join(\" \");\n}\n\nlet employeeName = buildName(\"Joseph\", \"Samuel\", \"Lucas\", \"MacKinzie\");\n\n나머지 매개변수는 무한적인 수의 선택적 매개변수로 처리됩니다.Rest 매개변수에 인수를 전달할 때는 원하는 만큼 사용할 수 있으며 심지어 통과할 수 없습니다.컴파일러는 줄임표 (...) 다음에 전달된 인수들을 배열을 작성하여 함수에서 사용할 수 있습니다.\n줄임표(...)는 나머지 매개변수가 있는 함수의 타입에도 사용됩니다:\nfunction buildName(firstName: string, ...restOfName: string[]) {\n    return firstName + \" \" + restOfName.join(\" \");\n}\n\nlet buildNameFun: (fname: string, ...rest: string[]) => string = buildName;\n\nthis\nJavaScript에서 this를 사용법을 배우는 것은 일종의 통과 의례입니다.TypeScript는 JavaScript의 상위 집합이기 때문에 TypeScript 개발자들도 this을 사용하는 방법과 올바르게 사용되고 있지 않을 때를 찾아내는 방법을 배워야 합니다.JavaScript에서 this가 어떻게 작동하는지 알아야 한다면 Yehuda Katz의 Understanding JavaScript Function Invocation and \"this\"를 먼저 읽어보세요.Yehuda의 글에는 this의 내부 동작을 잘 설명하기 때문에 여기서는 기본적인 내용만 다룰 것입니다.\nthis와 화살표 함수 (this and arrow functions)\nJavaScript에서 this는 함수가 호출될 때 설정되는 변수입니다.매우 강력하고 유연한 기능이지만 함수가 실행되는 상황에 대해 항상 알고 있어야 하는 시간이 듭니다.특히 함수를 반환하거나 함수를 인수로 전달할 때 악명 높을 정도로 혼란스럽습니다.\n예제를 살펴보겠습니다:\nlet deck = {\n    suits: [\"hearts\", \"spades\", \"clubs\", \"diamonds\"],\n    cards: Array(52),\n    createCardPicker: function() {\n        return function() {\n            let pickedCard = Math.floor(Math.random() * 52);\n            let pickedSuit = Math.floor(pickedCard / 13);\n\n            return {suit: this.suits[pickedSuit], card: pickedCard % 13};\n        }\n    }\n}\n\nlet cardPicker = deck.createCardPicker();\nlet pickedCard = cardPicker();\n\nalert(\"card: \" + pickedCard.card + \" of \" + pickedCard.suit);\n\ncreateCardPicker는 자체적으로 함수를 반환하는 함수입니다.예제를 실행하려고 하면 alert 대신 오류가 발생합니다.createCardPicker에 의해 생성된 함수에서 사용되는 this가 deck 객체 대신에 window로 설정되어 있기 때문입니다.왜냐하면 cardPicker()는 자기 자신을 호출하기 때문입니다.이와 같이 최상위 비-메서드 구문 호출은 this에 window를 사용합니다.(주의사항 : 엄격모드(strict mode)에서 this는 window보다는 undefined가 될 것입니다).\n나중에 사용할 함수를 반환하기 전에 함수에 올바른 this가 연결되도록하여 이를 해결할 수 있습니다.\n이렇게하면 나중에 어떻게 사용되든 상관없이 원래의 deck객체를 볼 수 있습니다.이를 위해 함수 표현식을 ECMAScript 6의 화살표 구문으로 변경하여 사용합니다.화살표 함수는 호출된 곳이 아닌 함수가 생성 된 곳에서 this를 캡처합니다:\nlet deck = {\n    suits: [\"hearts\", \"spades\", \"clubs\", \"diamonds\"],\n    cards: Array(52),\n    createCardPicker: function() {\n        // 주의: 아래 줄은 이제 화살표 함수입니다. 여기에서 'this'를 캡처할 수 있습니다.\n        return () => {\n            let pickedCard = Math.floor(Math.random() * 52);\n            let pickedSuit = Math.floor(pickedCard / 13);\n\n            return {suit: this.suits[pickedSuit], card: pickedCard % 13};\n        }\n    }\n}\n\nlet cardPicker = deck.createCardPicker();\nlet pickedCard = cardPicker();\n\nalert(\"card: \" + pickedCard.card + \" of \" + pickedCard.suit);\n\n더 좋은 점은 컴파일러에 --noImplicitThis 신호를 넘겨주면 TypeScript가 실수를 했을 때 경고를 합니다.this.suits[pickedSuit]에서 this는 any 타입입니다.\nthis parameters\n불행히도 this.suits [pickedSuit]의 타입은 여전히any입니다.왜냐하면 this는 객체 리터럴 내부의 함수 표현식에서 왔기 때문입니다.이 문제를 해결하기 위해 명시적으로 this 매개변수를 제공할 수 있습니다.  \nthis 매개변수는 함수의 매개변수 목록에서 처음 나오는 가짜 매개변수입니다:\nfunction f(this: void) {\n    // 이 분리된 함수에서 'this'를 사용할 수 없는지 확인해보세요.\n}\n\n위의 예제에서 Card와 Deck에 몇 가지 인터페이스를 추가하여 타입을 더 명확하고 쉽게 재사용하기 쉽게 만들 수 있도록 하겠습니다\ninterface Card {\n    suit: string;\n    card: number;\n}\ninterface Deck {\n    suits: string[];\n    cards: number[];\n    createCardPicker(this: Deck): () => Card;\n}\nlet deck: Deck = {\n    suits: [\"hearts\", \"spades\", \"clubs\", \"diamonds\"],\n    cards: Array(52),\n    // 주의사항 : 이 함수는 이제 반드시 Deck 타입이어야합니다\n    createCardPicker: function(this: Deck) {\n        return () => {\n            let pickedCard = Math.floor(Math.random() * 52);\n            let pickedSuit = Math.floor(pickedCard / 13);\n\n            return {suit: this.suits[pickedSuit], card: pickedCard % 13};\n        }\n    }\n}\n\nlet cardPicker = deck.createCardPicker();\nlet pickedCard = cardPicker();\n\nalert(\"card: \" + pickedCard.card + \" of \" + pickedCard.suit);\n\n이제 TypeScript는createCardPicker가 Deck 객체에서 호출될 것으로 예상합니다.즉 this는 any가 아닌 Deck 타입입니다. 따라서 --noImplicitThis는 오류를 발생시키지 않습니다.\n콜백에서의 this 매개변수 (this parameters in callbacks)\n함수를 나중에 호출할 라이브러리에 전달할 때 콜백에서 this를 사용하여 오류가 발생할 수도 있습니다.왜냐하면 콜백을 호출하는 라이브러리가 표준 함수처럼 호출하기 때문에 this는 undefined가 될 것입니다.\n때때로 this 매개변수를 사용하여 콜백 오류를 방지할 수도 있습니다.\n첫 번째, 라이브러리 작성자는 콜백 타입에 this를 사용하여 annotate를 달아야 합니다:\ninterface UIElement {\n    addClickListener(onclick: (this: void, e: Event) => void): void;\n}\n\nthis : void는 addClickListener가 onclick이 this 타입을 필요로 하지 않는 함수라는 것을 의미합니다.\n두 번째, this를 사용하여 호출 코드와 함께 annotate를 달아야 합니다:\nclass Handler {\n    info: string;\n    onClickBad(this: Handler, e: Event) {\n        // 이런, 여기서 this를 사용했어요. 이 콜백을 사용하면 충돌으로 런타임 오류가 발생합니다.\n        this.info = e.message;\n    }\n}\nlet h = new Handler();\nuiElement.addClickListener(h.onClickBad); // 오류!\n\nthis가 annotated되어 있으면 onClickBad는 반드시 Handler의 인스턴스에서 호출되어야한다는 것을 명시해야 합니다.그런 다음 TypeScript는 addClickListener에 this : void가 있는 함수가 필요하다는 것을 발견합니다.오류를 해결하려면 this의 타입을 수정하세요:\nclass Handler {\n    info: string;\n    onClickGood(this: void, e: Event) {\n        // this의 타입이 void이기 때문에 여기서는 사용할 수 없습니다!\n        console.log('clicked!');\n    }\n}\nlet h = new Handler();\nuiElement.addClickListener(h.onClickGood);\n\nonClickGood는 this의 타입을 void로 지정하기 때문에 addClickListener에 전달할 수 있습니다.물론 this는 또한 this.info를 사용할 수 없다는 것을 의미합니다.두 가지 모두를 사용하려면 화살표 함수를 사용해야 합니다:\nclass Handler {\n    info: string;\n    onClickGood = (e: Event) => { this.info = e.message }\n}\n\n이것은 화살표 함수가 this를 캡처하지 않기 때문에 효과적입니다.때문에 기대하는 것 같이 항상 this : void를 넘겨줄 수 있습니다.\n단점은 Handler 타입의 객체마다 하나의 화살표 함수가 생성된다는 것입니다.반면에 메서드는 한 번만 만들어지고 핸들러의 프로토 타입에 소속됩니다.이러한 객체는 핸들러 타입의 모든 객체 사이에 공유됩니다.\n오버로드 (Overloads)\nJavaScript는 본질적으로 매우 동적인 언어입니다.단일 JavaScript 함수가 전달된 인수의 형태를 기반으로 서로 다른 타입의 객체를 반환하는 것은 드문 일이 아닙니다.\nlet suits = [\"hearts\", \"spades\", \"clubs\", \"diamonds\"];\n\nfunction pickCard(x): any {\n    // 객체 / 배열로 작업하고 있는지 확인해보세요\n    // 그렇다면 그것들은 덱을 주고 사용자는 카드를 선택할 것입니다.\n    if (typeof x == \"object\") {\n        let pickedCard = Math.floor(Math.random() * x.length);\n        return pickedCard;\n    }\n    // 그렇지 않으면 카드를 선택하게하세요.\n    else if (typeof x == \"number\") {\n        let pickedSuit = Math.floor(x / 13);\n        return { suit: suits[pickedSuit], card: x % 13 };\n    }\n}\n\nlet myDeck = [{ suit: \"diamonds\", card: 2 }, { suit: \"spades\", card: 10 }, { suit: \"hearts\", card: 4 }];\nlet pickedCard1 = myDeck[pickCard(myDeck)];\nalert(\"card: \" + pickedCard1.card + \" of \" + pickedCard1.suit);\n\nlet pickedCard2 = pickCard(15);\nalert(\"card: \" + pickedCard2.card + \" of \" + pickedCard2.suit);\n\n여기서 pickCard 함수는 사용자가 무엇을 전달했는지에 따라 두 개의 서로 다른 내용을 반환합니다.사용자가 deck를 나타내는 객체를 전달하면 함수가 card를 선택합니다.사용자가 card를 선택하면 그들이 선택한 card를 알려줍니다.하지만 이것을 어떻게 타입 시스템에 설명할까요?\n이에 대한 대답은 오버로드 목록과 동일한 함수에 대한 여러 함수 타입을 제공하는 것이다.이 목록은 컴파일러가 함수 호출을 해결하는 데 사용할 것입니다.pickCard가 받아들일 수 있는 것과 그것이 반환하는 것을 기술한 오버로드 목록을 작성해 보세요.\nlet suits = [\"hearts\", \"spades\", \"clubs\", \"diamonds\"];\n\nfunction pickCard(x: {suit: string; card: number; }[]): number;\nfunction pickCard(x: number): {suit: string; card: number; };\nfunction pickCard(x): any {\n    // 객체 / 배열로 작업하고 있는지 확인해보세요\n    // 그렇다면 그것들은 덱을 주고 사용자는 카드를 선택할 것입니다.\n    if (typeof x == \"object\") {\n        let pickedCard = Math.floor(Math.random() * x.length);\n        return pickedCard;\n    }\n    // 그렇지 않으면 카드를 선택하게하세요.\n    else if (typeof x == \"number\") {\n        let pickedSuit = Math.floor(x / 13);\n        return { suit: suits[pickedSuit], card: x % 13 };\n    }\n}\n\nlet myDeck = [{ suit: \"diamonds\", card: 2 }, { suit: \"spades\", card: 10 }, { suit: \"hearts\", card: 4 }];\nlet pickedCard1 = myDeck[pickCard(myDeck)];\nalert(\"card: \" + pickedCard1.card + \" of \" + pickedCard1.suit);\n\nlet pickedCard2 = pickCard(15);\nalert(\"card: \" + pickedCard2.card + \" of \" + pickedCard2.suit);\n\n이런 변화로 인해 오버로드가 pickCard 함수에 대한 타입-체크 호출을 제공합니다.\n컴파일러가 올바른 타입 검사를 선택하기 위해 기본 JavaScript와 비슷한 프로세스를 수행합니다.오버로드 목록을 살펴보고 제공된 매개변수를 사용하여 함수를 호출하는 첫 번째 오버로드 시도를 계속합니다.일치하는 것을 찾으면 이 오버로드를 올바른 오버로드로 선택합니다.이러한 이유 때문에 주문이 많아지면 가장 구체적인 것에서 가장 덜 구체적인 것으로 오버로드합니다.\nfunction pickCard (x) : any 조각은 오버로드 목록의 일부가 아니므로 두 개의 오버로드만 있습니다:하나는 객체를 취하고 하나는 숫자를 취합니다.pickCard를 다른 매개 변수 타입과 함께 호출하면 오류가 발생합니다.\n"},"pages/Generics.html":{"url":"pages/Generics.html","title":"제네릭","keywords":"","body":"소개 (Introduction)\n소프트웨어 공학의 주요 부분은 명확하고 일관된 API를 가질뿐만 아니라 재사용 가능한 컴포넌트를 구축하는 것입니다.현재의 데이터 뿐만 아니라 미래의 데이터에 대해서도 처리할 수 있는 컴포넌트는 대형 소프트웨어 시스템 구축을 위한 가장 유연한 기능을 제공할 것입니다.\nC# 및 Java와 같은 언어에서 재사용 가능한 컴포넌트를 만들기 위한 주요 도구 중 하나는 제네릭 즉 단일 타입이 아닌 다양한 타입을 처리할 수 있는 컴포넌트를 만드는 것입니다.이를 통해 사용자는 컴포넌트를 사용할 때 자신만의 타입을 사용할 수 있습니다.\n제네릭의 Hello World (Hello World of Generics)\n우선 제네릭의 \"Hello World\" 즉 identity 함수를 만들어 봅시다.이 identity 함수는 전달된 것을 그대로 반환하는 함수입니다.이는 echo 명령과 비슷한 방식으로 생각하면 됩니다.\n제네릭이 없다면 identity 함수에 특정 타입을 부여해야 합니다.\nfunction identity(arg: number): number {\n    return arg;\n}\n\n또는 any 타입을 사용하여 identity 함수를 만들 수 있습니다.\nfunction identity(arg: any): any {\n    return arg;\n}\n\nany를 사용하는 것은 분명히 함수가 arg에 대한 모든 타입을 전달 받을 수 있게되지만 실제로 함수가 반환할 때 그 타입이 무엇이었는지에 대한 정보를 잃어버립니다.만약 숫자를 인수로 전달하면 어떤 타입이든 반환횔 수 있다는 것을 알 수 있습니다.\n대신 어떤 타입이 반환될 것인지를 나타내는 데 사용할 수 있는 방식으로 인수 타입을 정하는 방법이 필요합니다.여기서는 값이 아닌 타입을 처리하는 특별한 종류의 변수인 타입 변수(type variable)을 사용할 것입니다.\nfunction identity(arg: T): T {\n    return arg;\n}\n\nidentity 함수에 타입변수 T 를 추가했습니다.이 T 는 함수 사용자가 제공한 타입(예: number)를 캡처하여 나중에 해당 정보를 사용할 수 있도록 합니다.또한 T 를 다시 반환 타입으로 사용합니다.자세히 보면 인수와 반환 타입에 동일한 타입이 사용되는 것을 볼 수 있습니다.이를 통해 함수의 안과 밖에서 타입에 대한 정보를 넘길 수 있습니다.\n이러한 모습의 identity 함수는 다양한 타입을 처리할 수 있기 때문에 일반적이라고 할 수 있습니다.any 를 사용하는 것과는 달리 인수와 반환 타입에 숫자를 사용하는 처음의 identity 함수와 동일합니다.(즉 어떠한 정보도 잃어버리지 않습니다)\n제네릭 identity 함수를 만든 후 두 가지 방법 중 하나로 호출할 수 있습니다.첫번째 방법은 타입 인수를 포함한 모든 인수를 함수에 전달하는 것입니다.\nlet output = identity(\"myString\");  // 반환 타입은 'string' 입니다.\n\n여기서는 함수 호출에 대한 인수 중 하나인 T 를 string 으로 명시적으로 정했으며 인수에는 () 를 사용하는 것과 달리 <> 를 사용했습니다.\n두번째 방법은 더 일반적인 방법이기도 합니다.여기서는 타입 인수 추론(type argument inference) 를 사용합니다.즉 함수에 전달하는 인수 타입에 따라 컴파일러가 자동으로 T 값을 설정합니다.\nlet output = identity(\"myString\");  // 반환 타입은 'string' 입니다.\n\n꺾쇠 괄호(<>) 안에 명시적으로 타입을 전달할 필요가 없습니다.컴파일러는 그저 \"myString\" 의 값을 보고 T 를 그 타입으로 설정합니다.타입 인수 추론은 코드를 더 짧고 가독성 있게 유지하는 유용한 도구가 될 수 있지만 보다 복잡한 예제에서는 컴파일러가 타입을 추론하지 못하면 앞의 예제에서 했던 것 처럼 타입 인수를 명시적으로 전달해야 할 수도 있습니다.\n제네릭 타입 변수 (Generic Type Variables)\n제네릭을 사용하기 시작할 때  identity 와 같은 제네릭 함수를 만들면 컴파일러는 함수 내부에 제네릭으로 타입이 지정된 매개변수를 올바르게 사용하도록 합니다.즉 실제로 이러한 매개변수를 모든 타입이 될 수 있는 것처럼 취급힙니다.\n앞에서 본 identity 함수를 보겠습니다.\nfunction identity(arg: T): T {\n    return arg;\n}\n\n각 호출과 함께 콘솔에 인수 arg 의 길이를 기록하고 싶다면 어떻게 해야할까요?\n이렇게 할지도 모릅니다:\nfunction loggingIdentity(arg: T): T {\n    console.log(arg.length);  // 오류 : T는 .length 메소드를 가지고 있지 않습니다.\n    return arg;\n}\n\n컴파일러는 arg 의 .length 멤버를 사용하고 있다는 오류를 주지만 arg 모듈에는 이 멤버가 없다고 할 수는 없습니다.이전에 타입 변수가 모든 타입이 될 수 있다고 했습니다.따라서 누군가 .length 멤버가 없는 number 를 전달 할 수 있을 것입니다.\n실제로 이 함수가 T 대신 T 배열을 처리한다고 가정해 봅시다.그러면 배열을 처리할 수 있기 때문에 .length 멤버가 사용 가능해야 합니다.다른 타입의 배열을 생성하는 함수로 이것을 설명하겠습니다:\nfunction loggingIdentity(arg: T[]): T[] {\n    console.log(arg.length);  // Array는 .length 멤버가 있습니다. 오류 없음.\n    return arg;\n}\n\nloggingIdentity 는 타입 매개 변수 T 를 인수로 받고 arg 는 T 배열이며 T 배열을 반환합니다.숫자 배열을 인수로 넘기면 T 가 number 에 바인딩 되기 때문에 숫자 배열을 반환할 것입니다.이렇게하면 모든 타입이 아닌 처리하고자 하는 타입의 일부로 제네릭 타입 변수 T 를 사용하여 유연성을 높일 수 있습니다.\n혹은 다음 예제와 같이 작성할 수 있습니다.\nfunction loggingIdentity(arg: Array): Array {\n    console.log(arg.length);  // Array는 .length 멤버가 있습니다. 오류 없음.\n    return arg;\n}\n\n이미 다른 언어의 타입 스타일에 대해 잘 알고 있을 것입니다.다음장에서는 Array 와 같이 자신만의 제네릭 타입을 만드는 방법을 다룰 것입니다.\n제네릭 타입 (Generic Types)\n이전 장에서는 다양한 타입의 함수를 처리하는 제네릭 identity 함수를 만들었습니다.이 장에서는 함수 자체의 타입과 제네릭 인터페이스를 만드는 방법에 대하여 살펴보겠습니다.\n제네릭 함수의 타입은 함수 선언과 비슷하게 타입 매개변수가 먼저 나열된 비 제네릭 함수의 타입은 같습니다.\nfunction identity(arg: T): T {\n    return arg;\n}\n\nlet myIdentity: (arg: T) => T = identity;\n\n타입 변수의 수와 타입 변수의 사용이 일치하다면 제네릭 타입 매개변수에 다른 이름을 사용할 수도 있습니다.\nfunction identity(arg: T): T {\n    return arg;\n}\n\nlet myIdentity: (arg: U) => U = identity;\n\n제네릭 타입을 객체 리터럴 타입의 호출 형식으로도 사용할 수 있습니다:\nfunction identity(arg: T): T {\n    return arg;\n}\n\nlet myIdentity: {(arg: T): T} = identity;\n\n따라서 첫번째 제네릭 인터페이스를 작성하게 됩니다.앞의 예제에서 객체 리터럴을 가져와 인터페이스로 옮깁니다.\ninterface GenericIdentityFn {\n    (arg: T): T;\n}\n\nfunction identity(arg: T): T {\n    return arg;\n}\n\nlet myIdentity: GenericIdentityFn = identity;\n\n비슷한 예에서 제네릭 매개변수를 전체 인터페이스의 매개변수로 이동하려고 할 수 있습니다.이렇게하면 일반적으로 사용하는 유형(예: Dictionary 가 아닌 Dictionary) 을 볼 수 있습니다.이것은 인터페이스의 다른 모든 멤버가 타입 매개변수를 볼 수 있게합니다.\ninterface GenericIdentityFn {\n    (arg: T): T;\n}\n\nfunction identity(arg: T): T {\n    return arg;\n}\n\nlet myIdentity: GenericIdentityFn = identity;\n\n예제를 약간 다른 것으로 바꿔보겠습니다.제네릭 함수 대신 제네릭 타입의 일부인 비 제네릭 함수 signature로 설명하겠습니다.우리가 GenericIdentityFn 을 사용할 때 대응하는 타입 매개변수(여기서는 number)를 지정할 필요가 있고 호출 형식을 효과적으로 고정시킬 것입니다.언제 직접 호출 형식에 타입 파라미터를 삽입해야 하고 언제 인터페이스 자체에 삽입해야하는지를 이해하는 것이 타입의 어떤 측면이 제네릭인지 설명하는데 도움이 될 것입니다.\n제네릭 인터페이스 외에도 제네릭 클래스를 만들 수 있습니다.하지만 제네릭 열거형과 네임스페이스는 만들 수 없습니다.\n제네릭 클래스 (Generic Classes)\n제네릭 클래스는 제네릭 인터페이스와 형태가 비슷합니다.제네릭 클래스는 클래스 이름 다음에 꺾쇠 괄호(<>)로 묶인 제네릭 타입 매개변수들을 갖습니다.\nclass GenericNumber {\n    zeroValue: T;\n    add: (x: T, y: T) => T;\n}\n\nlet myGenericNumber = new GenericNumber();\nmyGenericNumber.zeroValue = 0;\nmyGenericNumber.add = function(x, y) { return x + y; };\n\n이것은 GenericNumber 문자 그대로 number 타입만 사용하도록 제한하는 것이 없다는 것을 눈치 챘을 것입니다.\n대신 string 이나 더 복잡한 객체를 사용할 수 있을 것입니다.\nlet stringNumeric = new GenericNumber();\nstringNumeric.zeroValue = \"\";\nstringNumeric.add = function(x, y) { return x + y; };\n\nalert(stringNumeric.add(stringNumeric.zeroValue, \"test\"));\n\n인터페이스와 마찬가지로 타입 매개변수를 클래스 자체에 두면 클래스의 모든 속성이 동일한 타입으로 작동하도록 할 수 있습니다.\n클래스 섹션에서 다루었던 것처럼 클래스에는 정적인 측면과 인스턴스 측면의 두가지 측면이 있습니다.제네릭 클래스는 정적 측면 보다는 인스턴스 측면에서만 제네릭이므로 클래스를 사용할 때 정적 멤버(static member)는 클래스의 타입 매개변수를 사용할 수 없습니다.\n제네릭 제약조건 (Generic Constraints)\n이전의 예제를 기억한다면 타입들에 어떤 기능이 있는지에 대한 지식이 있는 타입에서 작동하는 제네릭 함수를 작성해야 할 때가 있습니다.loggingIdentity 예제에서는 arg의 .length 프로퍼티에 접근하기를 원했지만 컴파일러는 모든 타입이 .length 속성을 가지고 있음을 증명할 수 없었습니다.그래서 컴파일러는 이러한 가정을 하지 않도록 경고를 줍니다.\nfunction loggingIdentity(arg: T): T {\n    console.log(arg.length);  // 오류 : T는 .length 메소드를 가지고 있지 않습니다.\n    return arg;\n}\n\n모든 타입으로 작업하는 대신 이 함수가 .length 프로퍼티를 가진 모든 타입에서 작동하도록 제한을 두고 싶을 것입니다.타입에 이 멤버가 있으면 타입을 허용하지만 적어도 이 멤버가 있어야 합니다.그렇게 하기 위해서는 T 가 무엇이 될 수 있는지에 대한 제약으로서 요구 사항을 작성해야 합니다.\n그러기 위해 제약 조건을 설명하는 인터페이스를 만들 것입니다.여기에서는 하나의 .length 프로퍼티를 가진 인터페이스를 만들고 이 인터페이스와 extends 키워드를 사용하여 제약조건을 나타냅니다.\ninterface Lengthwise {\n    length: number;\n}\n\nfunction loggingIdentity(arg: T): T {\n    console.log(arg.length);  // 이제 .length 프로퍼티가 있으므로 더이상 오류가 없습니다.\n    return arg;\n}\n\n제네릭 함수는 이제 제한되어 있으므로 더이상 모든 타입에서 작동하지 않습니다.\nloggingIdentity(3);  // 오류, number 는 .length 프로퍼티가 없습니다.\n\n대신 모든 필수 프로퍼티가 있는 타입의 값을 전달해야 합니다.\nloggingIdentity({length: 10, value: 3});\n\n제네릭 제약조건에서 타입 매개변수 사용 (Using Type Parameters in Generic Constraints)\n다른 타입 매개 변수에 의해 제한되는 타입 매개변수를 선언할 수 있습니다.예를 들어 여기서는 이름을 가진 객체의 프로퍼티를 가져오려고 합니다.실수로 obj에 존재하지 않는 프로퍼티를 잡아내지 않도록 하고자 합니다. 그래서 두가지 타입 사이에 제약조건을 적용할 것입니다:\nfunction getProperty(obj: T, key: K) {\n    return obj[key];\n}\n\nlet x = { a: 1, b: 2, c: 3, d: 4 };\n\ngetProperty(x, \"a\"); // 오류 없음\ngetProperty(x, \"m\"); // 오류 : 타입 'm'의 인수를 'a' | 'b' | 'c' | 'd' 에 할당 할 수 없습니다.\n\n제네릭에서 클래스 타입 사용 (Using Class Types in Generics)\n제네릭을 사용하여 TypeSciprt에서 팩토리를 생성할 때 생성자 함수를 사용하여 클래스 타입을 참조해야 합니다.\n예를 들어\nfunction create(c: {new(): T; }): T {\n    return new c();\n}\n\n아래의 고급 예제는 프로토타입 프로퍼티를 사용하여 생성자 함수와 클래스 타입의 인스턴스 사이의 관계를 추론하고 제한합니다.\nclass BeeKeeper {\n    hasMask: boolean;\n}\n\nclass ZooKeeper {\n    nametag: string;\n}\n\nclass Animal {\n    numLegs: number;\n}\n\nclass Bee extends Animal {\n    keeper: BeeKeeper;\n}\n\nclass Lion extends Animal {\n    keeper: ZooKeeper;\n}\n\nfunction createInstance(c: new () => A): A {\n    return new c();\n}\n\ncreateInstance(Lion).keeper.nametag;  // 타입 체크!\ncreateInstance(Bee).keeper.hasMask;   // 타입 체크!\n\n"},"pages/Enums.html":{"url":"pages/Enums.html","title":"열거형","keywords":"","body":"열거형 (Enums)\n열거형을 사용하면 이름이 있는 상수들을 정의할 수 있습니다.열거형의 사용은 문서의 의도나 명확한 사례들을 쉽게 만들 수 있습니다.TypeScript 는 숫자 및 문자열 기반 열거형을 모두 제공합니다.\n숫자 열거형 (Numeric enums)\n먼저 숫자 열거형으로 시작합니다.다른 언어에서 열거형을 접해봤다면 더 익숙 할 것입니다.열거형은 enum 키워드를 사용하여 정의할 수 있습니다.\nenum Direction {\n    Up = 1,\n    Down,\n    Left,\n    Right,\n}\n\n위에서 Up 는 1 로 초기화된 숫자 열거형입니다.아래에 이어서 등장하는 멤버들은 자동으로 증가합니다.즉, Direction.Up 은 1, Down 은 2, Left 는 3, Right 는 4 입니다.\n원한다면 초기화를 완전히 없앨 수도 있습니다.\nenum Direction {\n    Up,\n    Down,\n    Left,\n    Right,\n}\n\n여기에서는 Up 은 0 이며, Down 은 1 이 됩니다.이 자동 증가 동작은 멤버의 값 자체에 신경 쓰지 않고 각 열거형이 동일한 열거형의 다른 값과 구별되는 경우에 유용합니다.\n열거형을 사용하는 것은 간단합니다: 열거형 자체의 속성으로 모든 멤버에 엑섹스하고, 열거형의 이름을 사용하여 타입을 선언합니다.\nenum Response {\n    No = 0,\n    Yes = 1,\n}\n\nfunction respond(recipient: string, message: Response): void {\n    // ...\n}\n\nrespond(\"Princess Caroline\", Response.Yes)\n\n숫자 열거형은 계산된, 상수 멤버 (computed and constant members)에 혼합될 수 있습니다.단편적으로 초기화가 없는 열거형은 상수 또는 다른 상수 열거형의 멤버로 초기화된 숫자 열거형을 따라야할 필요가 있습니다.즉, 다음은 허용되지 않습니다:\nenum E {\n    A = getSomeValue(),\n    B, // 오류 ! A 는 상수로 초기화되지 않았으므로 B에는 초기화가 필요합니다.\n}\n\n문자 열거형 (String enums)\n문자 열거형은 비슷한 개념이지만 아래에 설명 된 것과 같이 약간의 미묘한 실행시 차이 (runtime differences)가 있습니다.문자 열거형에서 각 멤버는 문자열 리터럴 또는 다른 문자 열거형 멤버로 상수초기화되어야 합니다.\nenum Direction {\n    Up = \"UP\",\n    Down = \"DOWN\",\n    Left = \"LEFT\",\n    Right = \"RIGHT\",\n}\n\n문자 열거형은 자동 증가 동작을 하지 않지만 문자 열거형은 \"직렬화(serialize)\"하는 이점이 있습니다.즉, 디버깅 중이며 숫자 열거형의 런타임 값을 읽어야하는 경우 이 값은 종종 불투명합니다 - 즉, 자체적으로 유용한 의미를 전달하지는 않습니다.(역 매핑 (enums-at-runtime)이 도움이 될것입니다)문자 열거형을 사용하면 열거형 멤버 자체의 이름과 독립적으로 코드가 실행될 때 의미있고 읽기 쉬운 값을 제공합니다.\n별종 열거형 (Heterogeneous enums)\n엄밀히 말하자면 열거형은 문자열과 숫자 멤버와 섞일 수는 있지만 그렇게 할 이유는 없습니다.\nenum BooleanLikeHeterogeneousEnum {\n    No = 0,\n    Yes = \"YES\",\n}\n\nJavaScript의 런타임 동작을 실제로 사용하려고 하지 않는 한, 이렇게 하지 않는 것이 좋습니다. \n계산된 상수 멤버 (Computed and constant members)\n각 열거형 멤버에는 constant 또는 computed 중 하나일 수 있는 값이 있습니다.열거형 멤버는 다음과 같은 경우 상수로 간주됩니다:\n\n열거형의 첫 번째 멤버이며 초기화가 없으면 값이 0 으로 지정됩니다:\n// E.X 는 상수입니다:\nenum E { X }\n\n\n초기화가 없고 앞의 열거형 멤버가 숫자 인 상수입니다.이 경우 이후 나오는 열거형 멤버의 값은 이전 열거형 멤버의 값에 1을 더한 값이 됩니다.\n// E1 및 E2의 모든 열거형 멤버는 상수입니다.\n\nenum E1 { X, Y, Z }\n\nenum E2 {\n    A = 1, B, C\n}\n\n\n열거형 멤버는 상수 열거형 표현식으로 초기화됩니다.상수 열거형 표현식은 컴파일 시간에 완전히 평가될 수 있는 TypeScript의 하위 집합입니다.표현식은 다음과 같은 경우 상수 열거 표현식입니다:\n\n리터럴 열거 표현식 (기본적으로 문자 리터럴 또는 숫자 리터럴)\n이전에 정의된 상수 열거형 멤버 (다른 열거형에서 올 수 있음)에 대한 참조\n괄호로 묶인 상수 열거형 표현식\n상수 열거형 표현식에 적용된 +, -, ~ 단항 연산자 중 하나\n+, -, *, /, %, , >>, >>>, &, |, ^ 바이너리 연산자에 사용된 상수 열거형 표현식\n상수 열거형 표현식이 NaN 또는 Infinity 로 평가되는 것은 컴파일 타임 에러입니다.\n\n\n\n다른 모든 경우에는 열거형 멤버가 계산된(computed) 것으로 간주됩니다.\nenum FileAccess {\n    // 상수 멤버\n    None,\n    Read    = 1 \n통합 열거형 및 열거형 멤버 타입 (Union enums and enum member types)\n계산되지 않은 상수 열거형 멤버의 특수 하위 집합이 있습니다: 리터럴 열거형 멤버입니다.리터럴 열거형 멤버는 초기화된 값이 없거나 다음 값으로 초기화 된 값이 있는 상수 열거형 멤버입니다.\n\n문자열 리터럴 (예: \"foo\", \"bar\", \"baz\")\n숫자 리터럴 (예: 1, 100)\n숫자 리터럴에 적용되는 단항 마이너스 (예: -1, -100)\n\n열거형의 모든 멤버가 리터럴 열거형 값을 가질 때 일부 특수한 의미가 있습니다.\n첫번째는 열거형 멤버도 타입이 된다는 것입니다.\n예를 들어 특정 멤버는 열거형 멤버의 값만 가질 수 있습니다.\nenum ShapeKind {\n    Circle,\n    Square,\n}\n\ninterface Circle {\n    kind: ShapeKind.Circle;\n    radius: number;\n}\n\ninterface Square {\n    kind: ShapeKind.Square;\n    sideLength: number;\n}\n\nlet c: Circle = {\n    kind: ShapeKind.Square,\n    //    ~~~~~~~~~~~~~~~~ 오류!\n    radius: 100,\n}\n\n또 다른 변화는 열거 타입 자체가 각 열거형 멤버의 합집합(union) 이 된다는 것입니다.결합 타입 (union types)에 대해 아직 배우지 않았지만, 알아 두어야 할 것은 조합 열거형을 사용하는 타입 시스템이 열거형 자체에 존재하는 정확한 값들을 알고있다는 사실을 활용할 수 있다는 것입니다.이 때문에 TypeScript는 값을 잘못 비교하는 바보같은 버그를 잡을 수 있습니다.\nenum E {\n    Foo,\n    Bar,\n}\n\nfunction f(x: E) {\n    if (x !== E.Foo || x !== E.Bar) {\n        //             ~~~~~~~~~~~\n        // 오류! 연산자 '!==' 는 'E.Foo' 및 'E.Bar' 타입에 적용할 수 없습니다.\n    }\n}\n\n이 예제에서, 먼저 x 가 E.Foo 가 가 아닌지 검사했습니다.이 검사를 성공하면 || 가 실행되지 않고 'if' 의 내부가 실행됩니다.하지만 검사를 성공하지 못하면 x 는 오직 E.Foo 만 될 수 있습니다. 따라서 E.Bar 와 동일한 지 확인하는 것은 의미가 없습니다.\n런타임시의 열거형 (Enums at runtime)\n열거형은 런타임에 존재하는 실제 객체입니다.\n예를 들어 다음 열거형을 보면,\nenum E {\n    X, Y, Z\n}\n\n실제로 함수에 전달 될 수 있습니다.\nfunction f(obj: { X: number }) {\n    return obj.X;\n}\n\n// 작동합니다. 왜냐하면 `E` 는 숫자인 `X` 라는 속성을 가지고있기 떄문입니다.\nf(E);\n\n역 매핑 (Reverse mappings)\n멤버에 대한 속성 이름이 있는 객체를 만드는 것 외에도 숫자 열거형 멤버는 열거형 값에서 열거형의 이름으로 역 매핑(reverse mapping) 을 받습니다.\n예를 들어, 다음 예제에서:\nenum Enum {\n    A\n}\nlet a = Enum.A;\nlet nameOfA = Enum[a]; // \"A\"\n\nTypeScript는 이것을 다음 JavaScript로 컴파일합니다.\nvar Enum;\n(function (Enum) {\n    Enum[Enum[\"A\"] = 0] = \"A\";\n})(Enum || (Enum = {}));\nvar a = Enum.A;\nvar nameOfA = Enum[a]; // \"A\"\n\n이 생성된 코드에서 열거형은 전방향(forward) (name -> value) 매핑과 역방향(reverse) (value -> name) 매핑을 모두 저장하는 객체로 컴파일됩니다.다른 열거형 멤버에 대한 참조는 항상 속성 접근으로 방출되며 결고 인라인(inline)되지 않습니다.\n문자열 열거형 멤버는 역매핑을 생성하지 않습니다.\nconst 열거형 (const enums)\n대부분의 경우 열거형은 완벽하게 유효현 방법입니다.하지만 때떄로 요구사항이 더 엄격합니다.열거형의 값에 접근할 때 여부느이 생성된 코드와 추가적인 우회 비용을 피하려면 const 열거형을 사용 할 수 있습니다.const 열거형은 열거형에 const 지시자를 사용하여 정의합니다.\nconst enum Enum {\n    A = 1,\n    B = A * 2\n}\n\nconst 열거형은 상수 열거형 표현식만 사용할 수 있으며 일반 열거형과 달리 컴파일하는 동안 완전히 제거됩니다.const 열거형 멤버는 사용하는 사이트에서 인라인(inline)됩니다.const 열거형은 계산된 멤버를 가질수 없기 때문에 가능합니다.\nconst enum Directions {\n    Up,\n    Down,\n    Left,\n    Right\n}\n\nlet directions = [Directions.Up, Directions.Down, Directions.Left, Directions.Right]\n\n코드는 다음과 같이 컴파일 됩니다.\nvar directions = [0 /* Up */, 1 /* Down */, 2 /* Left */, 3 /* Right */];\n\n앰비언트 열거형 (Ambient enums)\ndeclare enum Enum {\n    A = 1,\n    B,\n    C = 2\n}\n\n앰비언트 열거형과 비앰비언트 열거형의 중요한 차이점 중 하나는 일반 열거형에서 초기화가 없는 멤버는 이전 열거형 멤버가 상수로 간주된다는 것입니다.반대로, 초기화가 없는 앰비언트 (그리고 비상수(non-const)) 열거형 멤버는 항상 계산된 것으로 간주됩니다.\n"},"pages/Type Inference.html":{"url":"pages/Type Inference.html","title":"타입 추론","keywords":"","body":"소개 (Introduction)\n이 장에서는 TypeScript의 타입 추론(Type Inference)에 대해 설명합니다.즉 타입이 어디서 어떻게 추론되는지 논의할 것입니다.\n기본 (Basics)\nTypeScript에는 타입을 명시해주지 않았을 때 타입 정보를 제공하기 위해 타입 추론이 사용되는 여러 위치가 있습니다.아래 예시 코드를 봅시다.\nlet x = 3;\n\nx 변수의 타입은 number 라고 추론됩니다.이러한 종류의 추론은 변수와 멤버를 초기화하거나 매개 변수의 기본값을 설정하거나 함수 반환 타입을 결정할 때 발생합니다.\n대부분의 타입 추론은 간단합니다.다음 장에서는 타입 추론의 미묘한 차이에 대하여 살펴보겠습니다.\n가장 일반적인 타입 (Best common type)\n여러 표현식에서 타입 추론이 이루어지면 그 표현식의 타입이 \"가장 일반적인 타입\"을 계산하는 데 사용됩니다.\n예:\nlet x = [0, 1, null];\n\n위의 예제에서 x 의 타입을 추론하기 위해서는 각 배열 요소의 타입을 반드시 고려해야합니다.여기서는 배열의 타입에 대한 두가지 선택사항 number 와 null 이 주어집니다.가장 일반적인 타입 알고리즘은 각 후보 타입을 고려하고 다른 호부와 호환되는 타입을 선택합니다.\n제공되는 후보 타입 중에서 가장 일반적인 타입을 선택해야하기 때문에 타입이 공통 구조를 공유하지만 모든 타입의 수퍼 타입(상위 타입)이 하나도 없는 경우도 있습니다.\n예:\nlet zoo = [new Rhino(), new Elephant(), new Snake()];\n\n이상적으로, zoo 배열이 Animal[] 로 추론되기를 원할 수도 있습니다.하지만 배열에는 정확히 Animal 타입의 객체가 없기 때문에 배열 요소 타입에 대한 추측을 할 수 없습니다.이 문제를 해결하려면 다른 유형의 수퍼 타입이 없는 유형을 명시적으로 제공해야합니다:\nlet zoo: Animal[] = [new Rhino(), new Elephant(), new Snake()];\n\n가장 일반적인 타입이 발견되지 않으면 추론의 결과는 유니온 배열(Union Array) 타입인 (Rhino | Elephant | Snake)[] 가 됩니다.\n상황적 타입 (Contextual Type)\n타입 추론은 TypeScript의 \"다른 방향\"에서도 작동합니다.이를 \"상황적 타이핑(Contextual Typing)\" 이라고 합니다.상황적 타입은 표현식의 타입의 위치에 의해 암시될 때 발생합니다. \n예:\nwindow.onmousedown = function(mouseEvent) {\n    console.log(mouseEvent.button);  //\n위의 코드에서 타입 오류를 제공하기 위해 TypeScript 타입 검사기는 Window.onmousedown 함수 타입을 사용하여 오른쪽 함수 표현식의 타입을 추론했습니다.이렇게 했을 때 mouseEvent 매개 변수의 타입을 추론할 수 있었습니다.이 함수 표현식이 문맥적으로 입력 된 위치에 있지 않으면 mouseEvent 매개변수는 any 타입을 가지며 오류는 발생하지 않습니다.\n문맥적으로 타입이 정해진 표현식에 명시적인 타입 정보가 포함되어 있면 해당 타입이 무시됩니다.\n위 예제를 작성했다면:\nwindow.onmousedown = function(mouseEvent: any) {\n    console.log(mouseEvent.button);  //\n매개 변수에 명시적 타입 주석이 있는 함수 표현식은 상황적 타입을 대체합니다.일단 그렇게 되면 상황적 타입이 적용되지 않으므로 오류가 발생하지 않습니다.\n상황적 타이핑은 많은 경우에 적용됩니다.일반적인 경우에는 함수 호출에 대한 인수, 할당의 우측 표현식, 타입 단언(Type Assertions), 객체의 멤버와 배열 리터럴, 그리고 반환문입니다.상황적 타입은 또한 가장 일반적인 타입의 후보 타입으로도 작용합니다.\n예:\nfunction createZoo(): Animal[] {\n    return [new Rhino(), new Elephant(), new Snake()];\n}\n\n이 예에서 가장 일반적인 타입은 Animal, Rhino, Elephant, 그리고 Snake 네가지 집합으로 구성됩니다.이 중에서 Animal 은 가장 일반적인 타입 알고리즘으로 선택이 가능합니다.\n"},"pages/Type Compatibility.html":{"url":"pages/Type Compatibility.html","title":"타입 호환성","keywords":"","body":"소개 (Introduction)\nTypeScript의 타입 호환성은 구조적 하위 타입을 기반으로합니다.구조적 타이핑은 멤버에 따라 타입을 관계시키는 방법입니다.이것은 이름뿐인 타이핑과 대조적입니다.\n다음 코드를 살펴보세요 :\ninterface Named {\n    name: string;\n}\n\nclass Person {\n    name: string;\n}\n\nlet p: Named;\n// 구조적 타이핑이니까 좋아요 \np = new Person();\n\nC# 또는 Java 같은 명사적인 언어에서는 person 클래스가 자신을 Named 인터페이스의 구현체로 명시적으로 기술하지 않기 때문에 동일한 코드가 오류가 될 수 있습니다.\nTypeScript의 구조적인 타입 시스템은 일반적으로 JavaScript 코드가 작성된 방식에 따라 설계되었습니다.\nJavaScript는 함수 표현식이나 객체 리터럴과 같은 익명의 객체를 광범위하게 사용하기 때문에 이름뿐인 구조적 타입 시스템 대신 JavaScript 라이브러리에서 발견되는 관계의 타입을 표현하는 것이 훨씬 자연스럽습니다.\n안전성에 대한 노트 (A Note on Soundness)\nTypeScript의 타입 시스템을 사용하면 완료시 알 수 없는 특정 작업을 안전하게 수행할 수 있습니다.타입 시스템에 이 프로퍼티가 있으면 그것은 \"타당\"한 것이 아니라고 합니다.\nTypeScript에서 부적절한 동작을 허용하는 곳을 신중하게 고려했으며 이 문서 전체에서 이러한 상황이 발생하는 곳과 그 뒤에있는 숨겨진 동기 부여 시나리오에 대해 설명합니다.\n시작하기 (Starting out)\nTypeScript의 구조 타입 시스템에 대한 기본적인 규칙은 y가 적어도x와 같은 멤버를 가지고 있다면 x는 y와 호환된다는 것입니다.\n예를 들어:\ninterface Named {\n    name: string;\n}\n\nlet x: Named;\n// y의 추론된 타입은 { name: string; location: string; } 입니다\nlet y = { name: \"Alice\", location: \"Seattle\" };\nx = y;\n\ny가 x에 할당될 수 있는지를 검사하기 위해 컴파일러는 x의 각 프로퍼티를 검사하여 y에서 상응하는 호환되는 프로퍼티를 찾습니다.\n이 경우 y는 문자열인 name 멤버를 가져야합니다. 그렇기 때문에 할당이 허용됩니다.\n함수 호출 인수를 검사할 때 다음과 같은 할당 규칙이 사용됩니다 :\nfunction greet(n: Named) {\n    alert(\"Hello, \" + n.name);\n}\ngreet(y); // 좋아요\n\ny는 별도의 location 프로퍼티를 가지고 있지만  이로 인해 오류가 생기는 것은 아니라는 점에 유의한다.  \n호환성을 검사할 때 대상의 타입 (이 경우 Named) 멤버만 고려됩니다.\n이 비교 프로세스는 재귀적으로 진행되어 각 구성원 및 하위 멤버의 유형을 탐색합니다.\n두 함수 비교 (Comparing two functions)\n원시적인 타입과 객체 타입을 비교하는 것은 비교적 간단하지만 호환성이 있는 것으로 간주되어야 하는 함수의 종류에 대한 질문은 좀 더 복잡합니다.\n먼저 매개변수 목록에서만 다른 두 함수의 기본 예제를 살펴보겠습니다 :\nlet x = (a: number) => 0;\nlet y = (b: number, s: string) => 0;\n\ny = x; // 좋아요\nx = y; // 오류\n\nx가 y에 할당될 수 있는지 확인하기 위해 우선 매개 변수 목록을 살펴봅니다.\nx의 각 매개 변수는 호환 가능한 타입을 가진 y에서 상응하는 매개 변수를 가져야합니다.\n매개 변수 이름은 고려되지 않으며 타입만 고려됩니다.이 경우x의 모든 매개 변수는y에 상응하는 호환 매개 변수를 가지므로 할당이 허용됩니다.\ny에는 x가 필요로 하지 않는 두 번째 매개 변수가 있어 할당이 허용되지 않으므로 오류입니다.\ny = x 예시와 같은 '버려지는' 매개변수를 허용하는지 이유가 의심스러울겁니다.이 할당이 허용되는 이유는 JavaScript에서 추가적인 함수 매개 변수를 무시하는 것이 상당히 흔한 일이기 때문입니다.  \n예를 들어 Array#forEach는 콜백 함수에 세 개의 매개 변수를 제공합니다 : 배열 요소와 해당 인덱스 및 포함된 배열\n그럼에도 불구하고 첫 번째 매개 변수 만 사용하는 콜백을 제공하는 것은 매우 유용합니다 :\nlet items = [1, 2, 3];\n\n// 이러한 추가 매개 변수를 강제로 사용하지 마세요\nitems.forEach((item, index, array) => console.log(item));\n\n// 괜찮을 거에요!\nitems.forEach(item => console.log(item));\n\n이제 타입 유형에 따라 다른 두 함수를 사용하여 반환 타입을 처리하는 방법을 살펴보겠습니다:\nlet x = () => ({name: \"Alice\"});\nlet y = () => ({name: \"Alice\", location: \"Seattle\"});\n\nx = y; // 좋아요\ny = x; // x에 location 프로퍼티가 없기 때문에 오류\n\n타입 시스템은 소스 함수의 반환 타입이 대상 타입의 반환 타입의 서브 타입이되도록 강제합니다.\n함수 매개변수의 Bivariance (Function Parameter Bivariance)\n함수 매개 변수의 타입을 비교할 때 원본 매개 변수가 대상 매개 변수에 할당 가능하거나 그 반대일 경우 할당이 성공합니다.\n이것은 호출한 측에서 더 특수화된 타입을 취하는 함수를 제공하게 될 수도 있지만 덜 특수화된 타입의 함수를 호출할 수 있기 때문에 바람직하지 않습니다.\n실제로 이런 종류의 오류는 드물기 때문에 이를 통해 많은 일반적인 JavaScript 패턴을 사용할 수 있습니다. \n간단한 예제:\nenum EventType { Mouse, Keyboard }\n\ninterface Event { timestamp: number; }\ninterface MouseEvent extends Event { x: number; y: number }\ninterface KeyEvent extends Event { keyCode: number }\n\nfunction listenEvent(eventType: EventType, handler: (n: Event) => void) {\n    /* ... */\n}\n\n// 부적절하지만 유익하고 일반적인\nlistenEvent(EventType.Mouse, (e: MouseEvent) => console.log(e.x + \",\" + e.y));\n\n// 안정성에서 바람직하지 않은 대안\nlistenEvent(EventType.Mouse, (e: Event) => console.log((e).x + \",\" + (e).y));\nlistenEvent(EventType.Mouse,  void>((e: MouseEvent) => console.log(e.x + \",\" + e.y)));\n\n//그래도 허용되지 않습니다(명확한 오류). 완전히 호환되지 않는 유형에 대해 적용되는 타입 안전성(Type safety)\nlistenEvent(EventType.Mouse, (e: number) => console.log(e));\n\n선택적 매개 변수와 나머지 매개 변수 (Optional Parameters and Rest Parameters)\n호환성을 위한 함수를 비교할 때 선택적 매개 변수와 필수 매개 변수는 서로 바꿔서 사용할 수 있습니다.원본 타입의 추가 선택적 매개 변수는 오류가 아니며 원본 타입의 해당 매개 변수가 없는 대상 타입의 선택적 매개 변수는 오류가 아닙니다.\n함수에 나머지 매개 변수가 있으면 함수가 선택적 매개 변수의 무한적입 집합인것처럼 처리됩니다.\n이는 타입 시스템의 관점에서 보면 중요하지 않지만 런타임 관점에서 선택적 매개 변수의 개념은 일반적으로 잘 적용되지 않습니다.왜냐하면 그 위치에서 undefined가 통과하는 것이 대부분의 함수가 같기 때문입니다.\n동기를 부여하는 예제는 콜백을 수행하고 일부(개발자에게) 예측 가능하지만 (타입 시스템에) 알 수 없는 인수를 사용하여 호출하는 함수의 일반적인 패턴입니다.\nfunction invokeLater(args: any[], callback: (...args: any[]) => void) {\n    /* ... 'arg'로 콜백을 호출합니다. ... */\n}\n\n// 부적절함 - invokeLater 임의의 수의 인수를 제공\"할 수도 있습니다\"\ninvokeLater([1, 2], (x, y) => console.log(x + \", \" + y));\n\n// 혼란스러움 (x와 y는 정말로 필요합니다) 발견 할 수 없습니다.\ninvokeLater([1, 2], (x?, y?) => console.log(x + \", \" + y));\n\n오버로드 함수 (Functions with overloads)\n함수에 오버로드가 있는 경우 원본 타입의 각 오버로드는 대상 타입의 호환가능한 시그니처과 일치해야합니다.이렇게하면 원본 함수와 동일한 모든 상황에서 대상 함수를 호출 할 수 있습니다.\n열거형 (Enums)\n열거형은 숫자와 호환되며 숫자는 열거형과 호환됩니다.다른 열거형에서 가져온 열거형의 값은 호환되지 않는 것으로 간주됩니다.\n예를 들어\nenum Status { Ready, Waiting };\nenum Color { Red, Blue, Green };\n\nlet status = Status.Ready;\nstatus = Color.Green;  // 오류\n\n클래스 (Classes)\n클래스는 한가지 예외를 제외하고 객체의 리터럴 타입 및 인터페이스와 유사하게 작동합니다: 정적 타입과 인스턴스 타입을 모두 포함합니다.  \n한 클래스 타입의 두 객체를 비교할 때 인스턴스의 멤버만 비교됩니다.정적 멤버 및 생성자는 호환성에 영향을 미치지 않습니다.\nclass Animal {\n    feet: number;\n    constructor(name: string, numFeet: number) { }\n}\n\nclass Size {\n    feet: number;\n    constructor(numFeet: number) { }\n}\n\nlet a: Animal;\nlet s: Size;\n\na = s;  // 좋아요\ns = a;  // 좋아요\n\n클래스의 Private와 protected 멤버 (Private and protected members in classes)\n클래스의 Private와 및 protected 멤버는 호환성에 영향을 줍니다.클래스의 인스턴스가 호환성을 검사할 때 대상 타입에 private 멤버가 포함되어 있으면 원본 타입에 동일한 클래스에서 비롯된 private 멤버가 포함되어 있어야합니다.마찬가지로 protected 멤버가 있는 인스턴스에도 동일하게 적용됩니다.이를 통해 클래스는 수퍼 클래스와 할당을 지정하는 것이 가능하지만 다른 상속 계층 구조의 클래스에서는 동일한 형태을 가질 수 없습니다.\n제네릭 (Generics)\nTypeScript는 구조적인 타입 시스템이기 때문에 타입 매개변수는 멤버 타입의 일부로 사용될 때 결과 타입에 만 영향을 줍니다.\n예를 들어\ninterface Empty {\n}\nlet x: Empty;\nlet y: Empty;\n\nx = y;  // 좋아요, y는 x의 구조와 일치합니다\n\n위의 경우 x와 y의 구조가 인수 타입를 차별화된 방식으로 사용하지 않기 때문에 호환 가능합니다.\nEmpty에 멤버를 추가하여 이 예제를 변경하면 어떻게 동작하는지 보여줍니다 :\ninterface NotEmpty {\n    data: T;\n}\nlet x: NotEmpty;\nlet y: NotEmpty;\n\nx = y;  // 오류, x와 y는 호환되지 않습니다\n\n이런 식으로 인수 타입이 명시된 제네릭 타입은 비-제네릭 타입처럼 동작합니다.\n인수 타입 지정되지 않은 제네릭 타입의 경우 모든 지정되지 않은 인수 타입 대신에 any를 지정하여 호환성을 검사합니다.그런 다음 결과로 나타나는 유형의 호환성을 일반적이지 않은 경우와 마찬가지로 검사합니다.그 결과 생성된 타입은 비-제네릭 경우와 마찬가지로 호환성을 검사합니다.\n예를 들어\nlet identity = function(x: T): T {\n    // ...\n}\n\nlet reverse = function(y: U): U {\n    // ...\n}\n\nidentity = reverse;  // 좋아요 왜냐하면 (x: any)=>any 일치 (y: any)=>any\n\n고급 주제 (Advanced Topics)\n하위 타입 vs 할당 (Subtype vs Assignment)\n지금까지는 언어 사양에 정의된 용어가 아닌 '호환성'을 사용했습니다.TypeScript에는 두 종류의 호환성이 있습니다: 하위 타입과 할당\n이러한 할당과 any에서와 숫자 값을 상응하는 열거형까지 할당을 허용하는 규칙과 하위 호환성을 확장에서만 차이가 있다.\n다른 위치는 상황에 따라 두 가지 호환 메커니즘 중 하나를 사용합니다.실용적인 목적을 위해 타입 호환성은 implements와 extends의 경우에도 할당 호환성에 의해 결정됩니다.\n자세한 내용은 TypeScript 사양을 참조하십시오.\n"},"pages/Advanced Types.html":{"url":"pages/Advanced Types.html","title":"고급 타입","keywords":"","body":"교차 타입 (Intersection Types)\n교차 타입은 다양한 타입을 하나로 결합합니다.따라서 기존 타입을 추가하여 필요한 모든 기능을 갖춘 단일 타입을 얻을 수 있습니다.\n예를 들어 Person & Serializable & Loggable은 Person 과 Serializable 이며 Loggable 입니다.즉 이 타입의 객체는 세 가지 타입의 모든 멤버를 갖게됩니다.\n믹스인에 사용되는 교차 타입과 고전적인 객체 지향 형식에 맞지 않는 다른 개념을 볼 수 있습니다.(JavaScript에 이러한 것들이 많습니다!)\n여기에 Mixin을 만드는 방법을 보여 주는 간단한 예제가 있습니다 :\nfunction extend(first: T, second: U): T & U {\n    let result = {};\n    for (let id in first) {\n        (result)[id] = (first)[id];\n    }\n    for (let id in second) {\n        if (!result.hasOwnProperty(id)) {\n            (result)[id] = (second)[id];\n        }\n    }\n    return result;\n}\n\nclass Person {\n    constructor(public name: string) { }\n}\ninterface Loggable {\n    log(): void;\n}\nclass ConsoleLogger implements Loggable {\n    log() {\n        // ...\n    }\n}\nvar jim = extend(new Person(\"Jim\"), new ConsoleLogger());\nvar n = jim.name;\njim.log();\n\n유니온 타입 (Union Types)\n유니온 타입은 교차 타입과 밀접한 관련이 있지만 매우 다르게 사용됩니다.때로는 매개 변수가 number 또는string이 될 것으로 기대하는 라이브러리를 실행하게 됩니다.\n예를 들어 다음과 같은 함수을 수행하십시오:\n/**\n * string 타입을 가져와서 왼쪽에 \"padding\"을 추가합니다.\n * 'padding'이 string인 경우에는 'padding'이 왼쪽에 추가됩니다.\n * 'padding'이 number인 경우에는 해당 개수의 공백이 왼쪽에 추가됩니다.\n */\nfunction padLeft(value: string, padding: any) {\n    if (typeof padding === \"number\") {\n        return Array(padding + 1).join(\" \") + value;\n    }\n    if (typeof padding === \"string\") {\n        return padding + value;\n    }\n    throw new Error(`Expected string or number, got '${padding}'.`);\n}\n\npadLeft(\"Hello world\", 4); // \"    Hello world\" 반환\n\npadLeft의 문제점은 padding 매개 변수가 any로 분류된다는 것입니다.즉 number이거나 string이 아닌 인수를 사용하여 호출할 수 있지만 TypeScript는 해당 인수와 함께 사용할 수 있습니다.\nlet indentedString = padLeft(\"Hello world\", true); // 컴파일 타임에는 통과되지만 런타임에는 실패합니다.\n\n전통적인 객체 지향 코드에서는 타입의 계층을 만들어 두 가지 타입을 추상화 할 수 있습니다.이것이 훨씬 더 명백하기는 하지만 또 약간 지나치기도 합니다.padLeft의 원래 버전에 대한 좋은 점 중 하나는 원시 값을 전달할 수 있다는 것입니다.이는 사용법이 간단하고 간결하다는 것을 의미했습니다.이 새로운 접근법은 이미 다른 곳에 있는 함수를 사용하려는 경우에도 도움이 되지 않습니다.\nany 대신 padding 매개변수에 union type 을 사용할 수 있습니다:\n/**\n * string 타입을 가져와서 왼쪽에 \"padding\"을 추가합니다.\n * 'padding'이 string인 경우에는 'padding'이 왼쪽에 추가됩니다.\n * 'padding'이 number인 경우에는 해당 개수의 공백이 왼쪽에 추가됩니다.\n */\nfunction padLeft(value: string, padding: string | number) {\n    // ...\n}\n\nlet indentedString = padLeft(\"Hello world\", true); // 컴파일 시 오류\n\n유니온 타입은 여러 타입 중 하나일 수 있는 값을 설명합니다.각 타입을 구분하기 위해 수직 막대(|)를 사용하므로 number | string | boolean은 number, string 또는 boolean 될 수 있는 값의 타입입니다.\n유니온 타입이 있는 값이 있으면 유니온의 모든 타입에 공통적인 멤버에만 접근할 수 있습니다.\ninterface Bird {\n    fly();\n    layEggs();\n}\n\ninterface Fish {\n    swim();\n    layEggs();\n}\n\nfunction getSmallPet(): Fish | Bird {\n    // ...\n}\n\nlet pet = getSmallPet();\npet.layEggs(); // 좋아요\npet.swim();    // 오류\n\n유니온 타입이 좀 까다로울 수도 있지만 익숙해지는 데는 약간의 직관이 필요할 뿐입니다.어떠한 값에 A | B 타입이 있다면 A 와 B 모두 가지고 있는 멤버가 있음을 확실히 알고 있습니다.이 예제에서 Bird는 fly라는 멤버를 가지고 있습니다.하지만 Bird | Fish의 변수 타입이 fly 메서드로 작용하고 있는지는 알 수 없습니다.런타임에 변수가 Fish 인경우 pet.fly() 호출은 실패합니다.\n타입 가드와 차별된 타입 (Type Guards and Differentiating Types)\n유니온 타입은 값을 취할 수있는 타입으로 겹칠 수있는 상황을 모델링 할 때 유용합니다.Fish를 가지고 있는지에 대해 구체적으로 알아야 할 필요가 있을 때 무슨 일이 일어날까요?JavaScript에서 두 가지 가능한 값을 구별하는 일반적인 용어는 멤버의 존재를 확인하는 것입니다.\n언급했듯이 유니온 타입의 모든 구성 요소에 포함될 수 있는 보장된 멤버에만 접근할 수 있습니다.\nlet pet = getSmallPet();\n\n// 이러한 각 프로퍼티 접근은 오류를 발생시킵니다.\nif (pet.swim) {\n    pet.swim();\n}\nelse if (pet.fly) {\n    pet.fly();\n}\n\n동일한 코드가 작동하도록 하려면 타입 단언을 사용해야 합니다 :\nlet pet = getSmallPet();\n\nif ((pet).swim) {\n    (pet).swim();\n}\nelse {\n    (pet).fly();\n}\n\n사용자 정의 타입 가드 (User-Defined Type Guards)\n타입 단언(type assertions)을 여러 번 사용해야 했다는 것에 주목하세요.일단 이 검사를 실시하면 각 지점에서 pet의 타입를 알 수 있습니다.\n그런 일이 있을 때 TypeScript에는 type guard라는 것이 있습니다.타입 가드(type guard)는 일부 스코프에서 타입을 보장하는 런타임 검사를 수행하는 표현식입니다.타입 가드를 정의하려면 반환 타입이 타입 명제 (type predicate) 인 함수를 정의하기만 하면 됩니다 :\nfunction isFish(pet: Fish | Bird): pet is Fish {\n    return (pet).swim !== undefined;\n}\n\npet is Fish는 이 예제에서 타입 명제입니다.명제는 parameterName is Type 형태을 취합니다, 여기서 parameterName은 현재 함수 시그니처의 매개 변수 이름이어야 합니다.\nIsFish가 일부 변수와 함께 호출될 때 원래 타입이 호환 가능하다면 TypeScript는 그 변수를 특정 타입으로 제한할 것입니다.\n// 'swim'과 'fly' 호출은 이제 모두 괜찮습니다.\n\nif (isFish(pet)) {\n    pet.swim();\n}\nelse {\n    pet.fly();\n}\n\nTypeScript는 pet이 if 스코프의 Fish라는 것을 알고 있을 뿐만 아니라,else 스코프에서는 Fish가 없다는 것을 알기 때문에 Bird가 있어야 합니다.\ntypeof 타입 가드 (typeof type guards)\n그럼 다시 돌아와 유니온 타입을 사용하는 padLeft 버전의 코드를 작성해보겠습니다.다음과 같이 타입 명제로 작성할 수 있습니다 :\nfunction isNumber(x: any): x is number {\n    return typeof x === \"number\";\n}\n\nfunction isString(x: any): x is string {\n    return typeof x === \"string\";\n}\n\nfunction padLeft(value: string, padding: string | number) {\n    if (isNumber(padding)) {\n        return Array(padding + 1).join(\" \") + value;\n    }\n    if (isString(padding)) {\n        return padding + value;\n    }\n    throw new Error(`Expected string or number, got '${padding}'.`);\n}\n\n그러나 어떤 타입이 원시적인지 알아내는 함수를 정의하는 것은 고통스럽습니다.다행스럽게도, typeScript가 자체적으로 타입 가드임을 인식하기 때문에 typeof x === \"number\"를 직접 함수로 추상화할 필요는 없습니다.즉 이러한 인라인 검사를 작성할 수 있다는 것을 의미합니다.\nfunction padLeft(value: string, padding: string | number) {\n    if (typeof padding === \"number\") {\n        return Array(padding + 1).join(\" \") + value;\n    }\n    if (typeof padding === \"string\") {\n        return padding + value;\n    }\n    throw new Error(`Expected string or number, got '${padding}'.`);\n}\n\n이것들의 typeof 타입 가드는 두가지 다른 형태로 인식됩니다: typeof v === \"typename\"와  typeof v !== \"typename\", 여기서  \"typename\"은 반드시 \"number\", \"string\", \"boolean\", 또는 \"symbol\".TypeScript에서 다른 문자열과 비교하는 것을 멈추지는 않지만 언어에서는 이러한 표현식을 타입 가드로 인식하지 않습니다.\ninstanceof 타입 가드 (instanceof type guards)\ntypeof 타입 가드를 읽었고 JavaScript에서 instanceof 연산자에 익숙하다면 아마 이 섹션에 대해 알 수 있을 것입니다.\ninstanceof 타입 가드는 생성자 함수를 사용하여 타입을 좁히는 방법입니다.예를 들어, 이전의 string-padder 예제를 차용해보겠습니다:\ninterface Padder {\n    getPaddingString(): string\n}\n\nclass SpaceRepeatingPadder implements Padder {\n    constructor(private numSpaces: number) { }\n    getPaddingString() {\n        return Array(this.numSpaces + 1).join(\" \");\n    }\n}\n\nclass StringPadder implements Padder {\n    constructor(private value: string) { }\n    getPaddingString() {\n        return this.value;\n    }\n}\n\nfunction getRandomPadder() {\n    return Math.random() \ninstanceof의 오른쪽에는 생성자 함수가 있어야 하며 TypeScript는 다음과 같이 범위를 좁혀 나갑니다:\n\n타입이 any가 아닌 경우 함수의 prototype 프로퍼티 타입\n해당 타입의 생성자 시그니처에 의해 반환된 타입의 결합\n\n이와 같은 순서로 진행됩니다.\nNullable types\nTypeScript는 null과 undefined 값을 가지는 두 가지 특별한 타입이 있습니다.이것을 기본 타입 섹션에서 간략하게 언급했었습니다.기본적으로 타입 체커는 null과 undefined를 모든 항목에 할당 가능한 것으로 간주합니다.사실상 null 과 undefined는 모든 타입의 유효한 값입니다.즉 방지하려는 경우조차도 any 타입에 할당되지 않도록 할 수 없습니다.null의 발명가 토니 호어는 이것을 \"10억 달러의 실수\"라고 부릅니다.\n--strictNullChecks에서 다음과 같이 수정할 수 있습니다: 변수를 선언할 때 자동으로 null 또는 undefined가 포함되지 않습니다.유니온 타입을 사용하여 명시적으로 포함할 수 있습니다:\nlet s = \"foo\";\ns = null; // 오류, 'null'은 'string'에 할당할 수 없습니다.\nlet sn: string | null = \"bar\";\nsn = null; // 좋아요\n\nsn = undefined; // 오류, 'undefined'는 'string | null'에 할당할 수 없습니다.\n\nTypeScript는 JavaScript의 의미론과 일치하도록 null과 undefined를 다르게 다루고 있습니다.string | null은 string | undefined 및 string | undefined | null과는 다른 타입입니다.\n선택적 매개변수와 프로퍼티 (Optional parameters and properties)\n--strictNullChecks와 선택적 매개 변수는 자동으로 | undefined를 추가합니다:\nfunction f(x: number, y?: number) {\n    return x + (y || 0);\n}\nf(1, 2);\nf(1);\nf(1, undefined);\nf(1, null); // 오류, 'null'은 'number | undefined'에 할당할 수 없습니다\n\n선택적 프로퍼티의 경우에도 동일합니다:\nclass C {\n    a: number;\n    b?: number;\n}\nlet c = new C();\nc.a = 12;\nc.a = undefined; // 오류, 'undefined'를 'number'에 할당 할 수 없습니다\nc.b = 13;\nc.b = undefined; // ok\nc.b = null; // 오류, 'null'은 'number | undefined'에 할당할 수 없습니다\n\n타입 가드와 타입 단언 (Type guards and type assertions)\nnullable 타입은 유니온으로 구현되기 때문에 타입 가드를 사용하여 null을 제거해야 합니다.다행히 JavaScript에서 작성하는 코드는 다음과 같습니다:\nfunction f(sn: string | null): string {\n    if (sn == null) {\n        return \"default\";\n    }\n    else {\n        return sn;\n    }\n}\n\n여기서 null을 제거하는 것은 확실히 좋지만 간단한 연산자도 사용할 수 있습니다.:\nfunction f(sn: string | null): string {\n    return sn || \"default\";\n}\n\n컴파일러가 null 또는 undefined를 제거할 수 없는 경우 타입 단언 연산자를 사용하여 수동으로 제거할 수 있습니다.구문은 후위에 ! 입니다: identifier!는 identifier의 타입 null과 undefined를 제거합니다:\nfunction broken(name: string | null): string {\n  function postfix(epithet: string) {\n    return name.charAt(0) + '.  the ' + epithet; // 오류, 'name'이 null일 수 있습니다.\n  }\n  name = name || \"Bob\";\n  return postfix(\"great\");\n}\n\nfunction fixed(name: string | null): string {\n  function postfix(epithet: string) {\n    return name!.charAt(0) + '.  the ' + epithet; // 좋아요\n  }\n  name = name || \"Bob\";\n  return postfix(\"great\");\n}\n\n이 예제에서 컴파일러가 중첩된 함수 내에서 null을 제거할 수 없기 때문에 여기에 중첩된 함수를 사용합니다(즉시실행함수 제외).특히 외부 함수에서 호출한 경우 중첩된 함수에 대한 모든 호출을 추적할 수 없기 때문입니다.함수가 어디에서 호출되는지 알지 못하면 body가 실행될 때 name의 타입이 무엇인지 알 수 없습니다.\n타입 별칭 (Type Aliases)\n타입 aliases는 타입의 새로운 이름을 생성합니다.타입 aliases은 인터페이스와 유사하지만 원시 타입, 유니온, 튜플 및 기타 직접 작성해야 하는 다른 타입의 이름을 지정할 수 있습니다.\ntype Name = string;\ntype NameResolver = () => string;\ntype NameOrResolver = Name | NameResolver;\nfunction getName(n: NameOrResolver): Name {\n    if (typeof n === \"string\") {\n        return n;\n    }\n    else {\n        return n();\n    }\n}\n\nAliasing(Type Aliases)은 실제로 새로운 타입을 생성하지는 않습니다 - 그 타입을 참조하기 위해 새로운 이름을 생성합니다.원시 값을 Aliasing 하는 것은 문서의 형태로 사용될 수 있지만 굉장히 유용하지 않습니다.\n인터페이스와 마찬가지로 타입 aliases도 일반적일 수 있습니다 - aliases 선언의 오른쪽에 타입 매개 변수를 추가하여 사용하면 됩니다:\ntype Container = { value: T };\n\ntype alias를 프로퍼티에서 참조할 수도 있습니다:\ntype Tree = {\n    value: T;\n    left: Tree;\n    right: Tree;\n}\n\n교차(intersection) 타입과 함께 mind-bending 타입을 만들 수 있습니다:\ntype LinkedList = T & { next: LinkedList };\n\ninterface Person {\n    name: string;\n}\n\nvar people: LinkedList;\nvar s = people.name;\nvar s = people.next.name;\nvar s = people.next.next.name;\nvar s = people.next.next.next.name;\n\n그러나 타입 alias가 선언의 다른 오른쪽에 나타나는 것은 불가능합니다:\ntype Yikes = Array; // 오류\n\nInterfaces vs. Type Aliases\n앞서 언급했듯이, 타입 type aliases는 인터페이스와 같은 역할을 할 수 있지만 몇 가지 미묘한 차이점이 있습니다.\n한가지 다른 점은 인터페이스가 어디에서나 사용되는 새로운 이름을 만들어 낸다는 것입니다.타입 aliases는 새로운 이름을 만들지 않습니다— 예를 들어 오류 메시지는 alias 이름을 사용하지 않습니다.아래 코드에서, 에디터의 interfaced 위로 마우스를 가져가면 Interface를 반환할 것을 보여주지만 aliased는 객체 리터럴 타입을 반환한다는 것을 보여줍니다.\ntype Alias = { num: number }\ninterface Interface {\n    num: number;\n}\ndeclare function aliased(arg: Alias): Alias;\ndeclare function interfaced(arg: Interface): Interface;\n\n두 번째 더 중요한 차이점은 타입 aliases를 다음에서 확장하거나 구현할 수 없다는 것입니다 (다른 타입을 확장/구현할 수도 없습니다).왜냐하면 소프트웨어의 이상적인 특성이 확장에 열려있다 가능한 경우 타입 alias에 대한 인터페이스를 사용해야 합니다.다른 한편으로는, 인터페이스로 일부 형태를 표현할 수 없고 유니온이나 튜플 타입을 사용해야 하는 경우 타입 aliases을 사용하는 것이 보통 좋습니다.\n문자열 리터럴 타입 (String Literal Types)\n문자열 리터럴 타입을 사용하여 문자열에 필요한 정확한 값을 지정할 수 있습니다.실제로 문자열 리터럴 타입은 유니온 타입, 타입 가드 및 타입 aliases와 잘 결합됩니다.이러한 기능을 함께 사용하여 문자열에서 열거형과 같은 동작을 얻을 수 있습니다.\ntype Easing = \"ease-in\" | \"ease-out\" | \"ease-in-out\";\nclass UIElement {\n    animate(dx: number, dy: number, easing: Easing) {\n        if (easing === \"ease-in\") {\n            // ...\n        }\n        else if (easing === \"ease-out\") {\n        }\n        else if (easing === \"ease-in-out\") {\n        }\n        else {\n            // 오류! null 또는 undefined로 통과해서는 안 됩니다.\n        }\n    }\n}\n\nlet button = new UIElement();\nbutton.animate(0, 0, \"ease-in\");\nbutton.animate(0, 0, \"uneasy\"); // 오류: 여기서 \"uneasy\"가 허용되지 않습니다.\n\n허용되는 세 문자열 중 아무거나 전달할 수 있지만 다른 문자열은 오류를 제공합니다.\n'\"uneasy\"' 타입의 인수를 타입의 매개 변수에 지정할 수 없습니다. '\"ease-in\" | \"ease-out\" | \"ease-in-out\"'\n\n오버로드를 구별하기 위해 동일한 방법으로 문자열 리터럴 타입을 사용할 수 있습니다.\nfunction createElement(tagName: \"img\"): HTMLImageElement;\nfunction createElement(tagName: \"input\"): HTMLInputElement;\n// ... 더 많은 오버로드 ...\nfunction createElement(tagName: string): Element {\n    // ... 코드는 여기에 있습니다 ...\n}\n\n숫자 리터럴 타입 (Numeric Literal Types)\nTypeScript에는 숫자 리터럴 타입도 있습니다.\nfunction rollDie(): 1 | 2 | 3 | 4 | 5 | 6 {\n    // ...\n}\n\n이들은 명시적으로 작성되는 경우는 거의 없으며 범위를 좁히는 것이 버그를 잡는 데 유용할 수 있습니다:\nfunction foo(x: number) {\n    if (x !== 1 || x !== 2) {\n        //         ~~~~~~~\n        // 연산자 '!=='는 '1'과 '2' 타입에는 적용 할 수 없습니다.\n    }\n}\n\n바꿔 말하면 x는 2와 비교할 때 1이어야 하며 이것은 위 체크가 유효하지 않은 비교를 하고 있음을 의미합니다.\n열거형 멤버 타입 (Enum Member Types)\n열거형 섹션에서 언급했듯이 열거형 멤버는 모든 멤버가 리터럴로 초기화될 때 타입을 가집니다.\n\"싱글톤 타입\"에 대해 이야기할 때 많은 시간 동안, 많은 사용자가 \"싱글톤 타입\"과 \"리터럴 타입\"을 바꿔 사용하겠지만 숫자/문자열 리터럴 타입뿐만 아니라 열거형 멤버 타입을 모두 참조합니다\n유니온 식별 (Discriminated Unions)\n싱글톤 타입, 유니온 타입, 타입 가드 및 타입 별칭을 결합하여 discriminated unions, tagged unions 또는 대수의(algebraic) 데이터 타입라는 고급 패턴을 빌드할 수 있습니다.Discriminated unions은 함수형 프로그래밍에 유용합니다.일부 언어는 자동으로 discriminate unions합니다; TypeScript는 현재 존재하는 JavaScript 패턴을 기반으로 합니다.세가지 구성요소가 있습니다:\n\n공통적인 싱글톤 타입의 특성을 갖는 타입 — discriminant.\n이러한 타입의 합집합을 취하는 타입 별칭 — union.\n공통 프로퍼티에 타입 가드.\n\ninterface Square {\n    kind: \"square\";\n    size: number;\n}\ninterface Rectangle {\n    kind: \"rectangle\";\n    width: number;\n    height: number;\n}\ninterface Circle {\n    kind: \"circle\";\n    radius: number;\n}\n\n먼저 결합할 인터페이스를 선언합니다.각 인터페이스는 다른 문자열 리터럴 타입을 가진 kind 프로퍼티를 가지고 있습니다.kind 프로퍼티는 discriminant 또는 tag라고 부릅니다.다른 프로퍼티는 각 인터페이스에 고유합니다.인터페이스는 현재 관련이 없습니다.그것들을 결합하여 넣습니다:\ntype Shape = Square | Rectangle | Circle;\n\n이제 식별 유니온을 사용합니다:\nfunction area(s: Shape) {\n    switch (s.kind) {\n        case \"square\": return s.size * s.size;\n        case \"rectangle\": return s.height * s.width;\n        case \"circle\": return Math.PI * s.radius ** 2;\n    }\n}\n\n철저한 검사 (Exhaustiveness checking)\n식별 유니온의 모든 변형을 다루지 않을 때 컴파일러에서 알려주면 좋겠습니다.예를 들어 Shape에 Triangle을 추가하면 area도 업데이트해야 합니다:\ntype Shape = Square | Rectangle | Circle | Triangle;\nfunction area(s: Shape) {\n    switch (s.kind) {\n        case \"square\": return s.size * s.size;\n        case \"rectangle\": return s.height * s.width;\n        case \"circle\": return Math.PI * s.radius ** 2;\n    }\n    // 여기서 오류가 발생해야합니다 - \"triangle\"을 핸들링하지 않았습니다\n}\n\n두 가지 방법이 있습니다.\n첫 번째는 --strictNullChecks를 켜고 반환 타입을 지정하는 것입니다 :\nfunction area(s: Shape): number { // 오류: returns number | undefined\n    switch (s.kind) {\n        case \"square\": return s.size * s.size;\n        case \"rectangle\": return s.height * s.width;\n        case \"circle\": return Math.PI * s.radius ** 2;\n    }\n}\n\nswitch가 더 이상 완전하지 않기 때문에 TypeScript는 그 함수가 때때로 undefined를 반환할 수 있다는 것을 알고 있습니다.명시적 반환 타입 number를 가지고 있다면 반환 타입이 실제로 number | undefined라는 오류가 발생합니다.그러나 이 방법은 매우 미묘하며 --strictNullChecks가 오래된 코드에서 항상 작동하는 것은 아닙니다.\n두 번째 방법은 컴파일러가 철저히 검사하기 위해 never 타입을 사용한다는 점입니다.\nfunction assertNever(x: never): never {\n    throw new Error(\"Unexpected object: \" + x);\n}\nfunction area(s: Shape) {\n    switch (s.kind) {\n        case \"square\": return s.size * s.size;\n        case \"rectangle\": return s.height * s.width;\n        case \"circle\": return Math.PI * s.radius ** 2;\n        default: return assertNever(s); // 누락된 경우 여기에 오류가 발생합니다\n    }\n}\n\n여기서, assertNever는 s가 never 타입인지 확인합니다 — 다른 모든 case가 종료된 후에 남겨진 타입이 제거되었습니다.case를 잊어버리면 s가 실제 타입을 가지게되고 타입 에러가 생깁니다.이 방법을 사용하려면 추가 함수을 정의해야 하지만 잊어버렸을 때 훨씬 더 분명해집니다.\n다형성의 this 타입 (Polymorphic this types)\n다형성의this 타입은 포함된 클래스나 인터페이스의 서브타입 타입을 나타냅니다.이것을 F-바운드 다형성이라고 합니다.\n따라서 계층적으로 완만한 인터페이스를 훨씬 쉽게 표현할 수 있습니다.각각의 연산자에 this를 반환하는 간단한 계산기가 있습니다:\nclass BasicCalculator {\n    public constructor(protected value: number = 0) { }\n    public currentValue(): number {\n        return this.value;\n    }\n    public add(operand: number): this {\n        this.value += operand;\n        return this;\n    }\n    public multiply(operand: number): this {\n        this.value *= operand;\n        return this;\n    }\n    // ... 다른 연산은 여기에 있습니다 ...\n}\n\nlet v = new BasicCalculator(2)\n            .multiply(5)\n            .add(1)\n            .currentValue();\n\n클래스는 this 타입을 사용하기 때문에 확장할 수 있으며 새로운 클래스는 변경 없이 이전 메서드를 사용할 수 있습니다.\nclass ScientificCalculator extends BasicCalculator {\n    public constructor(value = 0) {\n        super(value);\n    }\n    public sin() {\n        this.value = Math.sin(this.value);\n        return this;\n    }\n    // ... 다른 연산은 여기에 있습니다 ...\n}\n\nlet v = new ScientificCalculator(2)\n        .multiply(5)\n        .sin()\n        .add(1)\n        .currentValue();\n\nthis 타입이 없었다면 ScientificCalculator는 BasicCalculator를 확장하지도 못하고 완만한 인터페이스를 유지할 수 없었을 것입니다.multiply는 sin 메서드가 없는BasicCalculator를 반환했을 것입니다.그러나 this 타입의 경우 multiply는 this를 리턴합니다. this는 ScientificCalculator입니다.\n인덱스 타입 (Index types)\n인덱스 타입을 사용하면 동적 프로퍼티 이름을 사용하는 코드를 컴파일러가 검사하도록 할 수 있습니다.\n예를 들어 일반적인 Javascript 패턴은 객체에서 프로퍼티의 하위 집합을 선택하는 것입니다:\nfunction pluck(o, names) {\n    return names.map(n => o[n]);\n}\n\n다음은 인덱스 타입 쿼리 및 인덱스 접근 연산자를 사용하여 TypeScript에서 이 함수를 작성하고 사용하는 방법입니다.\nfunction pluck(o: T, names: K[]): T[K][] {\n  return names.map(n => o[n]);\n}\n\ninterface Person {\n    name: string;\n    age: number;\n}\nlet person: Person = {\n    name: 'Jarid',\n    age: 35\n};\nlet strings: string[] = pluck(person, ['name']); // 좋아요, string[]\n\n컴파일러는 name이 실제로 Person의 프로퍼티인지 확인합니다.이 예제는 몇 가지 새로운 타입의 연산자를 소개합니다.\n첫 번째는 keyof T으로 인덱스 타입 쿼리 연산자입니다.어떤 타입의 T에 대해서 keyof T는 T의 알려진 public 프로퍼티 이름들의 유니온입니다.\n예를 들어:\nlet personProps: keyof Person; // 'name' | 'age'\n\nkeyof Person은 'name' | 'age'와 완전히 호환됩니다.차이점은 Person에 또 다른 프로퍼티인 address: string을 추가하면 keyof Person은 자동으로 'name' | 'age' | 'address'로 업데이트된다는 점이다.그리고 pluck과 같은 일반적인 컨텍스트에서 keyof를 사용할 수 있으며 이때 프로퍼티 이름을 미리 알 수는 없습니다.즉 컴파일러가 올바른 프로퍼티 이름을 pluck으로 전달했는지 확인합니다:\npluck(person, ['age', 'unknown']); // 오류, 'unknown'은 'name' | 'age'에 없습니다\n\n두 번째 연산자는 T[K], 인덱스 접근 연산자(indexed access operator) 입니다.\n여기서 타입의 구문은 표현식을 반영합니다.\n즉 person['name']은 Person['name']타입을 가집니다 —\n예제에서는 단지 string입니다.\n하지만 인덱스 타입 쿼리와 마찬가지로 T[K]를 사용하면 실질적으로 힘이 발휘되는 일반적인 컨텍스트에서 사용할 수 있습니다.타입 변수 K extends keyof T를 확실히 만들어야 합니다.여기 getProperty라는 함수가 있는 또 다른 예제가 있습니다.\nfunction getProperty(o: T, name: K): T[K] {\n    return o[name]; // o[name]은 T[K] 타입입니다\n}\n\ngetProperty에서, o: T와 name: K는 o[name]: T[K]를 의미합니다.일단 T[K] 결과를 반환하면 컴파일러는 실제 키의 타입을 인스턴스화하므로 getProperty의 반환 타입은 사용자가 요청하는 프로퍼티에 따라 달라집니다.\nlet name: string = getProperty(person, 'name');\nlet age: number = getProperty(person, 'age');\nlet unknown = getProperty(person, 'unknown'); // 오류, 'unknown'은 'name' | 'age'에 없습니다\n\n인덱스 타입과 문자열 인덱스 시그니처 (Index types and string index signatures)\nkeyof와 T[K]는 문자열 인덱스 시그니처과 상호 작용합니다.문자열 인덱스 시그니처을 가진 타입을 가지고 있다면 keyof T는 단지string이 될 것입니다.그리고 T[string]은 인덱스 시그니처의 한가지 종류일뿐입니다:\ninterface Map {\n    [key: string]: T;\n}\nlet keys: keyof Map; // string\nlet value: Map['foo']; // number\n\nMapped types\n일반적인 작업은 기존 타입을 선택하고 각 프로퍼티를 선택적으로 만드는 것입니다:\ninterface PersonPartial {\n    name?: string;\n    age?: number;\n}\n\n또는 readonly를 원할 수도 있습니다.\ninterface PersonReadonly {\n    readonly name: string;\n    readonly age: number;\n}\n\n이러한 일은 Javascript에서 자주 발생하여 TypeScript는 이전 타입인 — mapped types 타입을 기반으로 새로운 타입을 만드는 방법을 제공합니다.mapped type에서 새로운 타입은 이전 타입의 각 프로퍼티를 동일한 방식으로 변환합니다.예를 들어 모든 프로퍼티 타입을 readonly 또는 선택적으로 설정할 수 있습니다.아래 몇 가지 예제가 있습니다:\ntype Readonly = {\n    readonly [P in keyof T]: T[P];\n}\ntype Partial = {\n    [P in keyof T]?: T[P];\n}\n\n그리고 그것을 사용하려면:\ntype PersonPartial = Partial;\ntype ReadonlyPerson = Readonly;\n\n가장 간단한 mapped type과 해당 부분을 살펴보겠습니다:\ntype Keys = 'option1' | 'option2';\ntype Flags = { [K in Keys]: boolean };\n\n구문은 인덱스 시그니처을 위한 구문과 for .. in 내부가 유사하게 사용됩니다.세 가지 파트로 나뉩니다:\n\n변수의 타입 K는 각 프로퍼티에 차례대로 바인딩 됩니다.\n문자열 리터럴 유니온 Keys는 반복할 프로퍼티의 이름을 포함합니다.\n결과적으로 생성된 프로퍼티의 타입.\n\n이 간단한 예제에서 Keys는 하드 코딩된 프로퍼티 이름의 리스트이고 프로퍼티 타입은 항상 boolean이므로 mapped type은 작성된 것과 같습니다.\ntype Flags = {\n    option1: boolean;\n    option2: boolean;\n}\n\n그러나 실제 애플리케이션은 위의 Readonly 또는 Partial처럼 보입니다.기존의 타입을 기반으로 하며 어떤 방식으로든 필드를 변환합니다.즉 keyof와 인덱스 접근 타입이 들어있는 곳입니다:\ntype NullablePerson = { [P in keyof Person]: Person[P] | null }\ntype PartialPerson = { [P in keyof Person]?: Person[P] }\n\n하지만 일반적인 버전을 사용하는 것이 더 유용합니다.\ntype Nullable = { [P in keyof T]: T[P] | null }\ntype Partial = { [P in keyof T]?: T[P] }\n\n이 예제에서 프로퍼티 목록은 keyof T이며 결과 타입은 T[P]의 변형입니다.이것은 mapped types의 일반적인 사용을 위한 좋은 템플릿입니다.왜냐하면 이러한 종류의 변환은 유사 동형(homomorphic)이기 때문에 매핑은 T의 프로퍼티에만 적용되고 다른 프로퍼티에는 적용되지 않습니다.컴파일러는 새로운 프로퍼티를 추가하기 전에 기존의 프로퍼티 지정자를 모두 복사할 수 있다는 것을 알고 있습니다.예를 들어 Person.name이 읽기 전용인 경우 Partial.name은 읽기 전용 및 선택적입니다.다음은 T[P]가 Proxy 클래스에 래핑된 또 하나의 예제입니다:\ntype Proxy = {\n    get(): T;\n    set(value: T): void;\n}\ntype Proxify = {\n    [P in keyof T]: Proxy;\n}\nfunction proxify(o: T): Proxify {\n   // ... proxies 감싸기 ...\n}\nlet proxyProps = proxify(props);\n\nReadonly와 Partial는 매우 유용하기 때문에 TypeScript의 표준 라이브러리에 Pick과 Record와 함께 포함되어 있습니다:\ntype Pick = {\n    [P in K]: T[P];\n}\ntype Record = {\n    [P in K]: T;\n}\n\nReadonly, Partial과 Pick은 동형(homomorphic)인 반면 Record는 그렇지 않습니다.Record가 동형(homomorphic)이 아닌 한가지 단서는 프로퍼티를 복사하는 데 입력 타입을 사용하지 않는다는 점입니다:\ntype ThreeStringProps = Record\n\n동형이 아닌 타입은 본질적으로 새로운 프로퍼티를 생성하기 때문에 어디에서나 프로퍼티 지정자를 복사할 수 없습니다.\nmapped types의 추론 (Inference from mapped types)\n이제는 타입의 프로퍼티를 래핑하는 방법을 알았으므로 다음으로 해야 할 일은 언래핑(푸는) 것입니다.다행히도 꽤 쉽습니다 :\nfunction unproxify(t: Proxify): T {\n    let result = {} as T;\n    for (const k in t) {\n        result[k] = t[k].get();\n    }\n    return result;\n}\n\nlet originalProps = unproxify(proxyProps);\n\n이 언래핑 추론은 동형 매핑 타입에서만 작동합니다.매핑된 타입이 동형이 아닌 경우에는 언래핑 함수에 명시적 타입 매개 변수를 지정해야 합니다.\n"},"pages/Symbols.html":{"url":"pages/Symbols.html","title":"심볼","keywords":"","body":"소개 (Introduction)\nECMAScript 2015에서 시작된 symbol은 number와 string같은 primitive 데이터 타입입니다.\nsymbol 값은 Symbol 생성자를 호출하여 생성됩니다.\nlet sym1 = Symbol();\n\nlet sym2 = Symbol(\"key\"); // 선택적 문자열 키\n\n심볼은 불변이며 고유합니다.\nlet sym2 = Symbol(\"key\");\nlet sym3 = Symbol(\"key\");\n\nsym2 === sym3; // false, 심볼은 고유합니다.\n\n문자열과 마찬가지로 심볼을 객체 프로퍼티의 키로 사용할 수 있습니다.\nlet sym = Symbol();\n\nlet obj = {\n    [sym]: \"value\"\n};\n\nconsole.log(obj[sym]); // \"value\"\n\n심볼을 계산된 프로퍼티 선언과 결합하여 객체 프로퍼티와 클래스 멤버를 선언할 수도 있습니다.\nconst getClassNameSymbol = Symbol();\n\nclass C {\n    [getClassNameSymbol](){\n       return \"C\";\n    }\n}\n\nlet c = new C();\nlet className = c[getClassNameSymbol](); // \"C\"\n\n잘 알려진 심볼 (Well-known Symbols)\n사용자 정의 심볼 외에도 잘 알려진 내장 심볼이 있습니다.내장 심볼은 내부 언어 동작을 나타내는 데 사용됩니다.\n다음은 잘 알려진 심볼 목록입니다.\nSymbol.hasInstance\n생성자 객체를 생성자의 인스턴스 중 하나로서 객체를 인식하는지 여부를 판단하는 메서드입니다. instanceof 연산자의 의미로 호출됩니다.\nSymbol.isConcatSpreadable\n객체가 Array.prototype.concat에 의해 배열 요소로 병합되어야 함을 나타내는 boolean 값입니다.\nSymbol.iterator\n객체의 기본 반복자를 반환하는 메서드입니다. for-of 구문에 의해 호출됩니다.\nSymbol.match\n정규 표현식을 문자열과 비교하는 정규 표현식 메서드입니다. String.prototype.match 메서드로 호출 됩니다.\nSymbol.replace\n일치하는 문자열의 부분 문자열을 대체하는 정규 표현식 메서드입니다. String.prototype.replace 메서드로 호출 됩니다.\nSymbol.search\n정규식과 일치하는 문자열에서 인덱스를 반환하는 정규식 메서드입니다. String.prototype.search 메서드로 호출 됩니다.\nSymbol.species\n파생된 객체를 만드는 데 사용되는 생성자 함수의 프로퍼티 값을 갖는 프로퍼티입니다.\nSymbol.split\n정규 표현식과 일치하는 인덱스에서 문자열을 분할하는 정규 표현식 메서드입니다.\n String.prototype.split 메서드에 의해 호출 됩니다.\nSymbol.toPrimitive\n객체를 해당하는 primitive 값으로 변환하는 방법입니다.\nToPrimitive 추상 동작에 의해 호출됩니다.\nSymbol.toStringTag\n객체의 기본 문자열 설명을 만드는 데 사용되는 String 값입니다.\n내장 메서드Object.prototype.toString로 호출 합니다.\nSymbol.unscopables\n자신의 프로퍼티 이름\"을\" 가지는 객체는 연관된 객체의 환경 바인딩에서 제외되는 프로퍼티 이름입니다.\n"},"pages/Iterators and Generators.html":{"url":"pages/Iterators and Generators.html","title":"이터레이터와 제네레이터","keywords":"","body":"이터러블 (Iterables)\nSymbol.iterator 프로퍼티에 대한 구현을 하고 있는 객체는 iterable로 간주됩니다.Array, Map, Set, String, Int32Array, Uint32Array 등과 같은 몇몇 내장 타입은 이미 구현된 Symbol.iterator 프로퍼티를 가지고 있습니다.\n객체의 Symbol.iterator 함수는 반복할 값 목록을 반환하는 것을 담당한다.\nfor..of 문 (statements)\nfor..of는 반복 가능한 객체에 대해 반복하며 객체에 대해 Symbol.iterator 프로퍼티를 호출합니다.\n다음은 배열의 간단한 for..of 루프입니다:\nlet someArray = [1, \"string\", false];\n\nfor (let entry of someArray) {\n    console.log(entry); // 1, \"string\", false\n}\n\nfor..of vs. for..in 문 (statements)\nfor..of와 for..in 모두 리스트를 반복합니다.반복되는 값은 다르지만, for..in은 반복되는 객체의 키 를 반환하는 반면 for..of는 반복되는 객체의 숫자(numeric) 프로퍼티의 값 을 반환합니다.\n다음은 이러한 차이를 보여 주는 예제입니다:\nlet list = [4, 5, 6];\n\nfor (let i in list) {\n   console.log(i); // \"0\", \"1\", \"2\",\n}\n\nfor (let i of list) {\n   console.log(i); // \"4\", \"5\", \"6\"\n}\n\n또 다른 차이점은 for..in은 어떠한 객체에서도 작동한다는 것입니다.이 객체의 프로퍼티를 검사하는 방법으로 사용됩니다.한편 for..of는 주로 반복 가능한 객체의 값에 관심이 있습니다.  \nMap과 Set 같은 내장객체는 저장된 값에 접근할 수 있게 해 주는 는Symbol.iterator 프로퍼티를 구현합니다.\nlet pets = new Set([\"Cat\", \"Dog\", \"Hamster\"]);\npets[\"species\"] = \"mammals\";\n\nfor (let pet in pets) {\n   console.log(pet); // \"species\"\n}\n\nfor (let pet of pets) {\n    console.log(pet); // \"Cat\", \"Dog\", \"Hamster\"\n}\n\n코드 생성\nES3와 ES5 대상 (Targeting ES5 and ES3)\nES5 또는 ES3를 대상으로 할 때 반복자는 Array 타입의 값에만 사용할 수 있습니다.\n컴파일러는 for..of 루프를 위한 간단한 for 루프를 생성할 것입니다.\n예를 들어 :\nlet numbers = [1, 2, 3];\nfor (let num of numbers) {\n    console.log(num);\n}\n\n다음과 같이 생성됩니다 :\nvar numbers = [1, 2, 3];\nfor (var _i = 0; _i \nECMAScript 2015 이상 대상 (Targeting ECMAScript 2015 and higher)\nECMAScipt 2015 호환 엔진을 대상으로 할 때 컴파일러는 엔진에서 내장 반복자 구현을 대상으로 for..of 루프를 생성합니다.\n"},"pages/Modules.html":{"url":"pages/Modules.html","title":"모듈","keywords":"","body":"\n용어에 대한 참고 사항:\nTypeScript 1.5에서는 명칭이 변경되었습니다.\"내부(Internal) 모듈\"은 이제 \"네임스페이스\"입니다.\"외부(External) 모듈\"은 이제 ECMAScript 2015의 용어에 맞게  간단히 \"모듈\"입니다\n(즉 모듈 X { 는 현재 선호되는 네임스페이스 X { 와 동일합니다).\n\n소개\nECMAScript 2015부터 JavaScript에는 모듈 개념이 있습니다. TypeScript는 이 개념을 공유합니다.\n모듈은 전역 스코프가 아닌 자체 스코프 내에서 실행됩니다.이는 export 형식 중 하나를 사용하여 명시적으로 내보내지 않는 한 모듈에 선언된 변수, 함수, 클래스 등이 모듈 외부에 보이지 않는다는 것을 의미합니다.반대로 다른 모듈에서 내보낸 변수, 함수, 클래스, 인터페이스 등을 사용하려면 import 형식 중 하나를 사용하여 가져와야 합니다.  \n모듈은 선언적입니다. 모듈 간의 관계는 파일 수준에서 imports 및 exports 측면에서 지정됩니다.\n모듈은 모듈 로더를 사용하여 또 다른 모듈을 import 합니다.런타임시 모듈 로더는 모듈을 실행하기 전에 모듈의 모든 의존성을 찾고 실행합니다.JavaScript에서 사용되는 잘 알려진 모듈 로더는 Node.js의 CommonJS모듈 로더이며 웹 애플리케이션의 경우 require.js입니다.\nTypeScript에서는 ECMAScript 2015와 마찬가지로 최상위 import 또는 export가 포함된 파일을 모듈로 간주합니다.\n내보내기 (Export)\n내보내기 선언 (Exporting a declaration)\n변수, 함수, 클래스, 타입 별칭(alias) 또는 인터페이스와 같은 선언문은 export 키워드를 추가하여 내보낼 수 있습니다.\nValidation.ts\nexport interface StringValidator {\n    isAcceptable(s: string): boolean;\n}\n\nZipCodeValidator.ts\nexport const numberRegexp = /^[0-9]+$/;\n\nexport class ZipCodeValidator implements StringValidator {\n    isAcceptable(s: string) {\n        return s.length === 5 && numberRegexp.test(s);\n    }\n}\n\n내보내기 문 (Export statements)\nExport 문은 사용자를 위해 Export의 이름을 변경해야 하는 경우에 유용하므로 위의 예제를 다음과 같이 작성할 수 있습니다:\nclass ZipCodeValidator implements StringValidator {\n    isAcceptable(s: string) {\n        return s.length === 5 && numberRegexp.test(s);\n    }\n}\nexport { ZipCodeValidator };\nexport { ZipCodeValidator as mainValidator };\n\n다시 내보내기 (Re-exports)\n종종 모듈은 다른 모듈을 확장하고 일부 기능을 부분적으로 노출합니다.다시 내보내기(re-export)는 로컬로 import하거나 로컬 변수를 도입하지 않습니다.\nParseIntBasedZipCodeValidator.ts\nexport class ParseIntBasedZipCodeValidator {\n    isAcceptable(s: string) {\n        return s.length === 5 && parseInt(s).toString() === s;\n    }\n}\n\n// 원본 validator 내보내지만 이름을 변경합니다\nexport {ZipCodeValidator as RegExpBasedZipCodeValidator} from \"./ZipCodeValidator\";\n\n선택적으로 모듈은 하나 이상의 모듈을 감싸고 export * from \"module\" 구문을 사용하여 모든 export를 결합할 수 있습니다.\nAllValidators.ts\nexport * from \"./StringValidator\"; // exports interface 'StringValidator'\nexport * from \"./LettersOnlyValidator\"; // exports class 'LettersOnlyValidator'\nexport * from \"./ZipCodeValidator\";  // exports class 'ZipCodeValidator'\n\nImport\nimport는 모듈에서 export 만큼 쉽습니다.export 선언을 가져오려면 아래의 import 형식 중 하나를 사용하십시오.\n모듈에서 단일 내보내기 가져오기 (Import a single export from a module)\nimport { ZipCodeValidator } from \"./ZipCodeValidator\";\n\nlet myValidator = new ZipCodeValidator();\n\nimports 이름을 변경할 수도 있습니다.\nimport { ZipCodeValidator as ZCV } from \"./ZipCodeValidator\";\nlet myValidator = new ZCV();\n\n전체 모듈을 단일 변수로 가져오고 이를 사용하여 모듈 내보내기에 접근하기 (Import the entire module into a single variable, and use it to access the module exports)\nimport * as validator from \"./ZipCodeValidator\";\nlet myValidator = new validator.ZipCodeValidator();\n\n부수 효과에 대한 모듈만 가져오기 (Import a module for side-effects only)\n권장되지는 않지만 일부 모듈은 다른 모듈에서 사용할 수 있는 글로벌 상태를 설정합니다.이러한 모듈에는 어떠한 exports도 없거나 사용자가 해당 exports에 관심이 없을 수 있습니다.\n이러한 모듈을 가져오려면 다음을 사용합니다:\nimport \"./my-module.js\";\n\n기본 내보내기 (Default exports)\n각 모듈은 선택적으로 default export를 내보낼 수 있습니다.Default exports는 default 키워드로 표시됩니다. 모듈별 default exports는 하나만 가능합니다.default exports는 다른 import 형식을 사용하여 가져옵니다.\ndefault exports는 정말 편리합니다.예를 들어 JQuery 같은 라이브러리에는 default export인 jQuery 또는 $가 있을 수 있으며 이를 $나 jQuery라는 이름으로도 가져올 수 있습니다.\nJQuery.d.ts\ndeclare let $: JQuery;\nexport default $;\n\nApp.ts\nimport $ from \"JQuery\";\n\n$(\"button.continue\").html( \"Next Step...\" );\n\n클래스 및 함수 선언은 default exports로 직접 작성될 수 있습니다.Default export 클래스와 함수 선언 네이밍은 선택적입니다.\nZipCodeValidator.ts\nexport default class ZipCodeValidator {\n    static numberRegexp = /^[0-9]+$/;\n    isAcceptable(s: string) {\n        return s.length === 5 && ZipCodeValidator.numberRegexp.test(s);\n    }\n}\n\nTest.ts\nimport validator from \"./ZipCodeValidator\";\n\nlet myValidator = new validator();\n\n또는\nStaticZipCodeValidator.ts\nconst numberRegexp = /^[0-9]+$/;\n\nexport default function (s: string) {\n    return s.length === 5 && numberRegexp.test(s);\n}\n\nTest.ts\nimport validate from \"./StaticZipCodeValidator\";\n\nlet strings = [\"Hello\", \"98052\", \"101\"];\n\n// 함수 유효성 검사 사용\nstrings.forEach(s => {\n  console.log(`\"${s}\" ${validate(s) ? \" matches\" : \" does not match\"}`);\n});\n\ndefault exports는 값 일 수도 있습니다:\nOneTwoThree.ts\nexport default \"123\";\n\nLog.ts\nimport num from \"./OneTwoThree\";\n\nconsole.log(num); // \"123\"\n\nexport = and import = require()\nCommonJS와 AMD 모두 일반적으로 모듈의 모든 exports를 포함하는 exports 객체 개념을 가지고 있습니다.\n또한 exports 객체를 커스텀 단일 객체로 대체하는 것을 지원합니다.Default exports는이 동작을 대신하는 역할을 합니다.그러나 그 둘은 호환되지 않습니다.TypeScript는 기존의 CommonJS와 AMD 워크플로우를 모델링하기 위해 export =를 지원합니다.\nexport = 구문은 모듈에서 export된 단일 객체를 지정합니다.\n클래스, 인터페이스, 네임스페이스, 함수 또는 열거형이 될 수 있습니다.\nexport =를 사용하여 모듈을 import 할 때 모듈을 import 하기 위해 TypeScript에 특정한 import module = require(\"module\")을 사용해야합니다.\nZipCodeValidator.ts\nlet numberRegexp = /^[0-9]+$/;\nclass ZipCodeValidator {\n    isAcceptable(s: string) {\n        return s.length === 5 && numberRegexp.test(s);\n    }\n}\nexport = ZipCodeValidator;\n\nTest.ts\nimport zip = require(\"./ZipCodeValidator\");\n\n// 시험용 샘플\nlet strings = [\"Hello\", \"98052\", \"101\"];\n\n// 사용할 Validators\nlet validator = new zip();\n\n// 각 문자열이 각 Validator를 통과했는지 여부를 보여줍니다.\nstrings.forEach(s => {\n  console.log(`\"${ s }\" - ${ validator.isAcceptable(s) ? \"matches\" : \"does not match\" }`);\n});\n\n모듈을 위한 코드 생성 (Code Generation for Modules)\n컴파일시 지정된 모듈 대상에 따라 컴파일러는 Node.js (CommonJS), require.js (AMD), UMD, SystemJS 또는 ECMAScript 2015 네이티브 모듈 (ES6)에 적절한 코드를 생성합니다.생성된 코드에서 define, require 및 register 호출에 대한 자세한 정보는 각 모듈 로더에 대한 문서를 참조하세요.\n이 간단한 예제는 import 및 export 중에 사용되는 이름이 모듈 로딩 코드로 어떻게 변환되는지 보여줍니다.\nSimpleModule.ts\nimport m = require(\"mod\");\nexport let t = m.something + 1;\n\nAMD / RequireJS SimpleModule.js\ndefine([\"require\", \"exports\", \"./mod\"], function (require, exports, mod_1) {\n    exports.t = mod_1.something + 1;\n});\n\nCommonJS / Node SimpleModule.js\nvar mod_1 = require(\"./mod\");\nexports.t = mod_1.something + 1;\n\nUMD SimpleModule.js\n(function (factory) {\n    if (typeof module === \"object\" && typeof module.exports === \"object\") {\n        var v = factory(require, exports); if (v !== undefined) module.exports = v;\n    }\n    else if (typeof define === \"function\" && define.amd) {\n        define([\"require\", \"exports\", \"./mod\"], factory);\n    }\n})(function (require, exports) {\n    var mod_1 = require(\"./mod\");\n    exports.t = mod_1.something + 1;\n});\n\nSystem SimpleModule.js\nSystem.register([\"./mod\"], function(exports_1) {\n    var mod_1;\n    var t;\n    return {\n        setters:[\n            function (mod_1_1) {\n                mod_1 = mod_1_1;\n            }],\n        execute: function() {\n            exports_1(\"t\", t = mod_1.something + 1);\n        }\n    }\n});\n\nNative ECMAScript 2015 modules SimpleModule.js\nimport { something } from \"./mod\";\nexport var t = something + 1;\n\n간단한 예제 (Simple Example)\n아래에서는 각 모듈에서 이름이 지정된 단일 export만 내보내도록 이전 예제에 사용된 Validator 구현을 통합했습니다.\n컴파일하려면 커맨드 라인에 모듈 대상을 지정해야 합니다.Node.js는 --module commonjs를 사용하세요.require.js의 경우 --module amd를 사용합니다.  \n예를 들어:\ntsc --module commonjs Test.ts\n\n컴파일시 각 모듈은 별도의 .js 파일이 됩니다.참조 태그와 마찬가지로 컴파일러는 의존된 파일들을 컴파일하기 위해 import 문을 따릅니다.\nValidation.ts\nexport interface StringValidator {\n    isAcceptable(s: string): boolean;\n}\n\nLettersOnlyValidator.ts\nimport { StringValidator } from \"./Validation\";\n\nconst lettersRegexp = /^[A-Za-z]+$/;\n\nexport class LettersOnlyValidator implements StringValidator {\n    isAcceptable(s: string) {\n        return lettersRegexp.test(s);\n    }\n}\n\nZipCodeValidator.ts\nimport { StringValidator } from \"./Validation\";\n\nconst numberRegexp = /^[0-9]+$/;\n\nexport class ZipCodeValidator implements StringValidator {\n    isAcceptable(s: string) {\n        return s.length === 5 && numberRegexp.test(s);\n    }\n}\n\nTest.ts\nimport { StringValidator } from \"./Validation\";\nimport { ZipCodeValidator } from \"./ZipCodeValidator\";\nimport { LettersOnlyValidator } from \"./LettersOnlyValidator\";\n\n// 시험용 샘플\nlet strings = [\"Hello\", \"98052\", \"101\"];\n\n// 사용할 Validators\nlet validators: { [s: string]: StringValidator; } = {};\nvalidators[\"ZIP code\"] = new ZipCodeValidator();\nvalidators[\"Letters only\"] = new LettersOnlyValidator();\n\n// 각 문자열이 각 Validator를 통과했는지 여부를 보여줍니다.\nstrings.forEach(s => {\n    for (let name in validators) {\n        console.log(`\"${ s }\" - ${ validators[name].isAcceptable(s) ? \"matches\" : \"does not match\" } ${ name }`);\n    }\n});\n\n선택적 모듈 로딩과 기타 고급 로딩 시나리오 (Optional Module Loading and Other Advanced Loading Scenarios)\n상황에 따라 일부 조건에서만 모듈을 로드할 수 있습니다.TypeScript에서는 아래의 패턴을 통해 다른 고급 로드 시나리오를 구현하여 타입 안전성을 잃지 않고 모듈 로더를 직접 호출할 수 있습니다.컴파일러는 각 모듈이 방출된 JavaScript에서 사용되는지 여부를 감지합니다.모듈 식별자가 타입 어노테이션의 일부로만 사용되고 표현식으로 사용되지 않으면 해당 모듈에 대한 require 호출이 방출하지 않습니다.사용하지 않는 참조를 제거하면 성능이 최적화되고 해당 모듈을 선택적으로 로드할 수 있습니다.\n이 패턴의 핵심 아이디어는 import id = require(\"...\")문이 모듈에 의해 노출된 타입에 접근할 수 있다는 것입니다.모듈 로더는 아래의 if 블록처럼 동적으로 (require를 통해) 호출됩니다.이는 참조 생략 최적화가 활용되어 모듈이 필요한 경우에만 로드됩니다.이 패턴이 작동하려면 import를 통해 정의된 symbol이 타입 위치에서만 사용되어야 합니다(즉 JavaScript로 방출될 수 있는 위치에 절대 존재하지 않습니다).\n타입 안전성을 유지하기 위해 typeof 키워드를 사용할 수 있습니다.typeof 키워드는 타입의 위치에서 사용될 때 값의 타입을 생성하며 이 경우 모듈의 타입이 됩니다.\nNode.js의 동적 모듈 로딩 (Dynamic Module Loading in Node.js)\ndeclare function require(moduleName: string): any;\n\nimport { ZipCodeValidator as Zip } from \"./ZipCodeValidator\";\n\nif (needZipValidation) {\n    let ZipCodeValidator: typeof Zip = require(\"./ZipCodeValidator\");\n    let validator = new ZipCodeValidator();\n    if (validator.isAcceptable(\"...\")) { /* ... */ }\n}\n\n샘플: require.js의 동적 모듈 로딩 (Dynamic Module Loading in require.js)\ndeclare function require(moduleNames: string[], onLoad: (...args: any[]) => void): void;\n\nimport * as Zip from \"./ZipCodeValidator\";\n\nif (needZipValidation) {\n    require([\"./ZipCodeValidator\"], (ZipCodeValidator: typeof Zip) => {\n        let validator = new ZipCodeValidator.ZipCodeValidator();\n        if (validator.isAcceptable(\"...\")) { /* ... */ }\n    });\n}\n\n샘플: System.js의 동적 모듈 로딩 (Dynamic Module Loading in System.js)\ndeclare const System: any;\n\nimport { ZipCodeValidator as Zip } from \"./ZipCodeValidator\";\n\nif (needZipValidation) {\n    System.import(\"./ZipCodeValidator\").then((ZipCodeValidator: typeof Zip) => {\n        var x = new ZipCodeValidator();\n        if (x.isAcceptable(\"...\")) { /* ... */ }\n    });\n}\n\n다른 JavaScript 라이브러리 사용 (Working with Other JavaScript Libraries)\nTypeScript로 작성되지 않은 라이브러리의 형태을 설명하려면 라이브러리가 나타내는 API를 선언해야 합니다.\n구현을 \"ambient\"으로 정의하지 않는 선언이라고 하며 \n일반적으로 이들은 .d.ts 파일에 정의되어 있습니다.C/C++에 익숙하다면 이것들을 .h파일로 생각할 수 있을 것입니다.\n몇 가지 예를 들어보겠습니다\nAmbient Modules\nNode.js에서 대부분의 작업은 하나 이상의 모듈을 로드하여 수행됩니다.각 모듈을 .d.ts 파일에 최상위 수준의 내보내기 선언으로 정의할 수 있지만 더 넓은 .d.ts 파일로 작성하는 것이 더 편리합니다.그렇게하기 위해서 ambient 네임스페이스와 비슷한 구조를 사용하지만 나중에 import 할 수 있는 모듈의 module 키워드와 따옴표 붙은 이름을 사용합니다.\n예를 들어:\nnode.d.ts (simplified excerpt)\ndeclare module \"url\" {\n    export interface Url {\n        protocol?: string;\n        hostname?: string;\n        pathname?: string;\n    }\n\n    export function parse(urlStr: string, parseQueryString?, slashesDenoteHost?): Url;\n}\n\ndeclare module \"path\" {\n    export function normalize(p: string): string;\n    export function join(...paths: any[]): string;\n    export var sep: string;\n}\n\n이제 ///  node.d.ts 를 만들 수 있고 import url = require(\"url\"); 또는 import * as URL from \"url\"\n를 사용하여 모듈을 적재할 수 있습니다.\n/// \nimport * as URL from \"url\";\nlet myUrl = URL.parse(\"http://www.typescriptlang.org\");\n\nShorthand ambient modules\n새로운 모듈을 사용하기 전에 선언을 작성하는 시간을 내고 싶지 않다면 shorthand 선언을 사용하여 빠르게 시작할 수 있습니다.\ndeclarations.d.ts\ndeclare module \"hot-new-module\";\n\nshorthand 모듈의 모든 imports는 any 타입을 가집니다.\nimport x, {y} from \"hot-new-module\";\nx(y);\n\nWildcard module declarations\nSystemJS 및 AMD 같은 일부 모듈 로더들은 JavaScript가 아닌 컨텐츠를 import 할 수 있습니다.일반적으로 특별한 로드의 의미론을 나타내는 접두사 또는 접미사를 사용한다.이러한 경우를 다루기 위해 Wildcard 모듈 선언을 사용할 수 있습니다.\ndeclare module \"*!text\" {\n    const content: string;\n    export default content;\n}\n// 일부는 그 반대의 방법을 사용합니다.\ndeclare module \"json!*\" {\n    const value: any;\n    export default value;\n}\n\n이제 \"*!text\" 또는 \"json!*\" 과 일치하는 것을 import 할 수 있습니다.\nimport fileContent from \"./xyz.txt!text\";\nimport data from \"json!http://example.com/data.json\";\nconsole.log(data, fileContent);\n\nUMD modules\n일부 라이브러리는 많은 모듈 로더에서 사용하도록 설계되었거나 모듈 로드가 없습니다 (글로벌 변수).이러한 모듈을 UMD 모듈이라고 합니다.이러한 라이브러리는 import 또는 글로벌 변수를 통해 접근할 수 있습니다.\n예를 들어:\nmath-lib.d.ts\nexport function isPrime(x: number): boolean;\nexport as namespace mathLib;\n\n그러면 라이브러리를 모듈에서 import로 사용할 수 있습니다.\nimport { isPrime } from \"math-lib\";\nisPrime(2);\nmathLib.isPrime(2); // 오류: 모듈 내부에서 전역 정의를 할 수 없습니다.\n\n글로벌 변수로 사용할 수도 있지만 스크립트 내부에서만 사용할 수 있습니다.(스크립트는 imports 또는 exports가 없는 파일입니다)\nmathLib.isPrime(2);\n\n모듈 구조화를 위한 가이드 (Guidance for structuring modules)\n최상위 레벨에 가깝게 내보내기 (Export as close to top-level as possible)\n모듈의 사용자들은 export 한 것들을 사용할 때 가능한 한 마찰이 적어야 합니다.너무 많은 중첩의 레벨을 추가하는 것은 다루기 힘들기 때문에 구조화 방법에 대해 신중히 생각하세요.\n모듈에서 네임스페이스를 export 하는 것은 중첩 계층을 너무 많이 추가하는 예입니다.네임스페이스가 필요할때도 있지만 모듈을 사용할 때는 추가적인 레벨의 간접 참조를 추가합니다.이는 사용자에게 재빠르게 고통이 될 수 있으며 일반적으로 불필요합니다.  \nexport 클래스의 정적 메서드에도 비슷한 문제가 있습니다 - 클래스 자체적으로 중첩 계층을 추가합니다.표현이나 의도가 명확하고 유용한 방식으로 증가하지 않는 한 간단한 헬퍼 함수를 내보내는 것을 고려하세요.\n단일 class 또는 function만 export하는 경우 export default를 사용하세요 (If you're only exporting a single class or function, use export default)\n\"최상위 레벨에 가깝게 내보내기\"가 모듈 사용자의 마찰을 줄이는 것처럼 default export를 도입하는 것도 마찬가지입니다.모듈의 주요 목적이 하나의 특정 export를 저장하는 것이라면 이를 default export로 export 하는 것을 고려해야 합니다.이렇게 하면 importing를 사용하며 실제로 import를 더 쉽게 사용할 수 있습니다.\n예를 들어:\nMyClass.ts\nexport default class SomeType {\n  constructor() { ... }\n}\n\nMyFunc.ts\nexport default function getThing() { return \"thing\"; }\n\nConsumer.ts\nimport t from \"./MyClass\";\nimport f from \"./MyFunc\";\nlet x = new t();\nconsole.log(f());\n\n이는 사용자를 위한 최적의 선택입니다.타입의 이름을 원하는 대로 지을 수 있으며(이 경우 t) 객체를 찾기 위해 과도하게 점을 찍을 필요가 없습니다.\n다수의 객체를 내보내는 경우 모두 최상위 레벨에 배치하세요. (If you're exporting multiple objects, put them all at top-level)\nMyThings.ts\nexport class SomeType { /* ... */ }\nexport function someFunc() { /* ... */ }\n\n반대로 가져올 때:\nimported 이름을 명시적으로 나열 (Explicitly list imported names)\nConsumer.ts\nimport { SomeType, someFunc } from \"./MyThings\";\nlet x = new SomeType();\nlet y = someFunc();\n\n다수를 importing 하는 경우 네임스페이스 import 패턴 사용 (Use the namespace import pattern if you're importing a large number of things)\nMyLargeModule.ts\nexport class Dog { ... }\nexport class Cat { ... }\nexport class Tree { ... }\nexport class Flower { ... }\n\nConsumer.ts\nimport * as myLargeModule from \"./MyLargeModule.ts\";\nlet x = new myLargeModule.Dog();\n\n확장을 위한 다시 내보내기 (Re-export to extend)\n종종 모듈의 기능을 확장해야 합니다.일반적인 JS 패턴은 JQuery 확장이 작동하는 것과 비슷한 extensions을 사용하여 원본 객체를 보강하는 것입니다.앞서 언급했듯이 모듈은 전역 네임스페이스 객체처럼 병합되지 않습니다.권장되는 해결책은 원본 객체를 변형시키지 않고 새로운 기능을 제공하는 새로운 엔티티를 export하는  것입니다.\nCalculator.ts 모듈에 정의된 간단한 계산기 구현을 고려해보세요.또한 모듈은 입력 문자열 목록을 전달하고 끝에 결과를 작성하여 계산기 기능을 테스트하는 헬퍼 함수를 exports 합니다.\nCalculator.ts\nexport class Calculator {\n    private current = 0;\n    private memory = 0;\n    private operator: string;\n\n    protected processDigit(digit: string, currentValue: number) {\n        if (digit >= \"0\" && digit = 0) {\n            return operator;\n        }\n    }\n\n    protected evaluateOperator(operator: string, left: number, right: number): number {\n        switch (this.operator) {\n            case \"+\": return left + right;\n            case \"-\": return left - right;\n            case \"*\": return left * right;\n            case \"/\": return left / right;\n        }\n    }\n\n    private evaluate() {\n        if (this.operator) {\n            this.memory = this.evaluateOperator(this.operator, this.memory, this.current);\n        }\n        else {\n            this.memory = this.current;\n        }\n        this.current = 0;\n    }\n\n    public handelChar(char: string) {\n        if (char === \"=\") {\n            this.evaluate();\n            return;\n        }\n        else {\n            let value = this.processDigit(char, this.current);\n            if (value !== undefined) {\n                this.current = value;\n                return;\n            }\n            else {\n                let value = this.processOperator(char);\n                if (value !== undefined) {\n                    this.evaluate();\n                    this.operator = value;\n                    return;\n                }\n            }\n        }\n        throw new Error(`Unsupported input: '${char}'`);\n    }\n\n    public getResult() {\n        return this.memory;\n    }\n}\n\nexport function test(c: Calculator, input: string) {\n    for (let i = 0; i \n다음은 test 함수를 사용한 계산기의 간단한 테스트입니다.\nTestCalculator.ts\nimport { Calculator, test } from \"./Calculator\";\n\n\nlet c = new Calculator();\ntest(c, \"1+2*33/11=\"); // 9\n\n이제 이것을 확장하여 10이 아닌 다른 수의 입력에 대한 지원을 추가하기 위한 ProgrammerCalculator.ts를 작성해 봅시다.\nProgrammerCalculator.ts\nimport { Calculator } from \"./Calculator\";\n\nclass ProgrammerCalculator extends Calculator {\n    static digits = [\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"A\", \"B\", \"C\", \"D\", \"E\", \"F\"];\n\n    constructor(public base: number) {\n        super();\n        if (base  ProgrammerCalculator.digits.length) {\n            throw new Error(\"base has to be within 0 to 16 inclusive.\");\n        }\n    }\n\n    protected processDigit(digit: string, currentValue: number) {\n        if (ProgrammerCalculator.digits.indexOf(digit) >= 0) {\n            return currentValue * this.base + ProgrammerCalculator.digits.indexOf(digit);\n        }\n    }\n}\n\n// 새롭게 확장된 계산기를 계산기로 export 합니다.\nexport { ProgrammerCalculator as Calculator };\n\n// 또한 헬퍼 함수를 export 합니다.\nexport { test } from \"./Calculator\";\n\n다음은 우리의 ProgrammerCalculator 클래스에 대한 테스트입니다.새로운 모듈 ProgrammerCalculator는 원래 Calculator 모듈과 비슷한 API 형태을 export 하지만 원본 모듈의 어떠한 객체도 보강하지 않습니다.\n다음은 ProgrammerCalculator 클래스에 대한 테스트입니다:\nTestProgrammerCalculator.ts\nimport { Calculator, test } from \"./ProgrammerCalculator\";\n\nlet c = new Calculator(2);\ntest(c, \"001+010=\"); // 3\n\n모듈에서 네임 스페이스를 사용하지 마세요 (Do not use namespaces in modules)\n모듈 기반 조직으로 처음 이동할 때의 트렌드는 추가 네임 스페이스 계층에 exports를 래핑하는 것입니다.모듈에는 자체적인 스코프가 있으며 exports 선언만 모듈 외부에서 볼 수 있습니다.이를 염두에 두고 네임스페이스는 모듈을 사용할 때 매우 작은 값을 제공합니다.\n조직 측면에서는 네임스페이스가 논리적으로 관련된 객체와 타입을 전역 스코프로 그룹화할 때 편리합니다.예를 들어 C#에서는 System.Collections의 모든 컬렉션 타입을 찾습니다.  \n타입을 계층적 네임스페이스로 구성하여 이러한 타입의 사용자에게 훌륭한 \"발견\" 경험을 제공합니다.반면 모듈은 필수적으로 파일 시스템에 이미 존재합니다.경로와 파일 이름으로 해결해야 하므로 사용할 수있는 논리적 조직 체계가 있습니다.목록 모듈이 포함된 /collections/generic/ 폴더를 사용할 수 있습니다.\n전역 스코프에서 충돌된 이름을 지정하지 않으려면 네임스페이스가 중요합니다.예를 들어  My.Application.Customer.AddForm과 My.Application.Order.AddForm 같은 이름이지만 다른 네임스페이스를 가진 두 가지 타입이 있을 수 있습니다.그러나 이것은 모듈과 관련된 문제는 아닙니다.모듈 내에서 동일한 이름을 가진 두 개의 객체를 갖는 그럴듯한 이유는 없습니다.사용자는 모듈을 참조하는 데 사용할 이름을 선택하게 되므로 우연한 이름 충돌은 불가능합니다.\n\n모듈과 네임스페이스에 대한 자세한 내용은 네임 스페이스와 모듈을 참조하세요.\n\n위험 신호 (Red Flags)\n다음은 모두 모듈 구조화를 위한 위험 요소들입니다.이 중 하나라도 파일에 적용되는 경우 외부 모듈의 네임스페이스를 지정하려고 하지 않는지 다시 확인하세요.\n\n오직 최상위 레벨 선언만 export namespace Foo { ... }인 파일 (Foo를 제거하고 모든 것을 '위로' 이동시키세요)\n단일 export class 또는 export function가 있는 파일 (export default 사용을 고려하세요)\n최상위 파일 위치에 동일한 export namespace Foo {를 가진 다수의 파일 (이것들이 Foo 하나로 결합될 것이라고 생각하지 마세요!)\n\n"},"pages/Namespaces.html":{"url":"pages/Namespaces.html","title":"네임스페이스","keywords":"","body":"\n용어에 대한 참고 사항:\nTypeScript 1.5에 명칭이 변경되었습니다.\"내부 모듈\"은 이제 \"네임스페이스\"입니다.\"외부 모듈\"은 ECMAScript 2015의 용어에 맞게 간단히 \"모듈\"입니다 (즉 모듈 X { 는 현재 선호되는 네임스페이스 X { 와 동일합니다).\n\n소개\n이 게시물은 TypeScript의 네임스페이스(이전의 \"내부 모듈\")를 사용하여 코드를 구성하는 다양한 방법을 간략하게 설명합니다.용어에 대해 언급할 때 \"내부(internal) 모듈\"은 이제 \"네임스페이스\"로 언급됩니다.또 내부 모듈을 선언할 때 module 키워드가 사용된 곳이라면 어디에서나 namespace 키워드를 대신 사용할 수 있습니다.비슷한 이름의 용어로 오버로드함으로써 새로운 사용자에게 주는 혼동을 방지합니다.\n첫 걸음 (First steps)\n먼저 이 페이지의 예제로 사용할 프로그램에서부터 시작해보겠습니다.웹 페이지의 양식에 대한 사용자 입력을 확인하거나 외부에서 제공하는 데이터 파일의 형식을 확인하기 위해 작성할 수 있는 간단한 문자열 유효성 검사기를 작성했습니다.\n단일 파일의 유효성 검사기 (Validators in a single file)\ninterface StringValidator {\n    isAcceptable(s: string): boolean;\n}\n\nlet lettersRegexp = /^[A-Za-z]+$/;\nlet numberRegexp = /^[0-9]+$/;\n\nclass LettersOnlyValidator implements StringValidator {\n    isAcceptable(s: string) {\n        return lettersRegexp.test(s);\n    }\n}\n\nclass ZipCodeValidator implements StringValidator {\n    isAcceptable(s: string) {\n        return s.length === 5 && numberRegexp.test(s);\n    }\n}\n\n// 시험용 샘플\nlet strings = [\"Hello\", \"98052\", \"101\"];\n\n// 사용할 Validators\nlet validators: { [s: string]: StringValidator; } = {};\nvalidators[\"ZIP code\"] = new ZipCodeValidator();\nvalidators[\"Letters only\"] = new LettersOnlyValidator();\n\n// 각 문자열이 Validator를 통과했는지 여부를 보여 줍니다.\nfor (let s of strings) {\n    for (let name in validators) {\n        let isMatch = validators[name].isAcceptable(s);\n        console.log(`'${ s }' ${ isMatch ? \"matches\" : \"does not match\" } '${ name }'.`);\n    }\n}\n\nNamespacing\nValidator를 더 추가함에 따라 타입을 추적하고 다른 객체와의 이름 충돌에 대해 걱정하지 않을 수 있는 일종의 조직 체계를 원할 것입니다.전역 네임스페이스에 다른 이름을 많이 추가하는 대신 객체를 네임스페이스로 마무리합시다.\n이 예제에서는 모든 validator 관련 엔티티를 Validation라는 네임스페이스로 이동합니다.여기서 인터페이스와 클래스를 네임스페이스 외부에서 볼 수 있기를 원하기 때문에 export를 머리말에 붙입니다.반대로 변수 lettersRegexp와 numberRegexp는 구현 세부 사항이므로 노출되지 않은 상태로 남아있어 네임스페이스 외부의 코드에는 보이지 않습니다.파일의 아래쪽에 있는 테스트 코드에서 (예: Validation.LettersOnlyValidator)와 같이 네임스페이스 외부에서 사용할 경우 타입의 이름을 확인해야 합니다.\nNamespaced Validators\nnamespace Validation {\n    export interface StringValidator {\n        isAcceptable(s: string): boolean;\n    }\n\n    const lettersRegexp = /^[A-Za-z]+$/;\n    const numberRegexp = /^[0-9]+$/;\n\n    export class LettersOnlyValidator implements StringValidator {\n        isAcceptable(s: string) {\n            return lettersRegexp.test(s);\n        }\n    }\n\n    export class ZipCodeValidator implements StringValidator {\n        isAcceptable(s: string) {\n            return s.length === 5 && numberRegexp.test(s);\n        }\n    }\n}\n\n// 시험용 샘플\nlet strings = [\"Hello\", \"98052\", \"101\"];\n\n// 사용할 Validators\nlet validators: { [s: string]: Validation.StringValidator; } = {};\nvalidators[\"ZIP code\"] = new Validation.ZipCodeValidator();\nvalidators[\"Letters only\"] = new Validation.LettersOnlyValidator();\n\n// 각 문자열이 Validator를 통과했는지 여부를 보여 줍니다.\nfor (let s of strings) {\n    for (let name in validators) {\n        console.log(`\"${ s }\" - ${ validators[name].isAcceptable(s) ? \"matches\" : \"does not match\" } ${ name }`);\n    }\n}\n\n파일 분할 (Splitting Across Files)\n애플리케이션이 증가함에 따라 코드를 여러 파일로 나누어 유지 보수하기 쉽게 만들려고 합니다.\nMulti-file namespaces\n여기서 Validation 네임스페이스를 많은 파일들로 나눌 것입니다.파일은 별개이지만 각각 동일한 네임스페이스에 기여할 수 있으며 모든 파일이 한곳에서 정의된 것처럼 사용할 수 있습니다.파일 간 의존성이 있기 때문에 컴파일러에게 파일들 간의 관계를 알려주는 참조 태그를 추가합니다.테스트 코드는 변경되지 않습니다.\nValidation.ts\nnamespace Validation {\n    export interface StringValidator {\n        isAcceptable(s: string): boolean;\n    }\n}\n\nLettersOnlyValidator.ts\n/// \nnamespace Validation {\n    const lettersRegexp = /^[A-Za-z]+$/;\n    export class LettersOnlyValidator implements StringValidator {\n        isAcceptable(s: string) {\n            return lettersRegexp.test(s);\n        }\n    }\n}\n\nZipCodeValidator.ts\n/// \nnamespace Validation {\n    const numberRegexp = /^[0-9]+$/;\n    export class ZipCodeValidator implements StringValidator {\n        isAcceptable(s: string) {\n            return s.length === 5 && numberRegexp.test(s);\n        }\n    }\n}\n\nTest.ts\n/// \n/// \n/// \n\n// 시험용 샘플\nlet strings = [\"Hello\", \"98052\", \"101\"];\n\n// 사용할 Validators\nlet validators: { [s: string]: Validation.StringValidator; } = {};\nvalidators[\"ZIP code\"] = new Validation.ZipCodeValidator();\nvalidators[\"Letters only\"] = new Validation.LettersOnlyValidator();\n\n// 각 문자열이 Validator를 통과했는지 여부를 보여 줍니다.\nfor (let s of strings) {\n    for (let name in validators) {\n        console.log(`\"${ s }\" - ${ validators[name].isAcceptable(s) ? \"matches\" : \"does not match\" } ${ name }`);\n    }\n}\n\n여러 파일이 포함되면 컴파일된 모든 코드를 로드해야 합니다.이 작업에는 두 가지 방법이 있습니다.\n먼저 --outFile을 사용하여 모든 입력 파일을 단일 JavaScript 출력 파일로 컴파일 할 수 있습니다:\ntsc --outFile sample.js Test.ts\n\n컴파일러는 파일에 있는 참조 태그를 기반으로 출력 파일을 자동으로 정렬합니다.각 파일을 개별적으로 지정할 수도 있습니다:\ntsc --outFile sample.js Validation.ts LettersOnlyValidator.ts ZipCodeValidator.ts Test.ts\n\n또는 파일별 컴파일(기본값)을 사용하여 각 입력 파일에 대한 JavaScript 파일을 하나씩 방출할 수 있습니다.만약 여러 개의 JS 파일이 생성되면 웹 페이지에 있는 태그를 사용하여 방출된 각 파일을 적절한 순서대로 로드해야 합니다.\n예를 들어:\nMyTestPage.html (excerpt)\n    \n    \n    \n    \n\n별칭 (Aliases)\n네임스페이스 작업을 단순화할 수 있는 또 다른 방법은 import x = require(\"name\")를 사용하여 일반적으로 사용되는 객체의 더 짧은 이름을 생성하는 것입니다.이러한 종류의 imports(별칭으로 불림)를 모듈 imports에서 생성된 객체를 포함한 모든 종류의 식별자에 사용할 수 있습니다.\nnamespace Shapes {\n    export namespace Polygons {\n        export class Triangle { }\n        export class Square { }\n    }\n}\n\nimport polygons = Shapes.Polygons;\nlet sq = new polygons.Square(); // 'new Shapes.Polygons.Square()'와 동일합니다\n\nrequire 키워드는 사용하지 않습니다. 대신 가져오는 심볼에 걸맞은 이름을 직접 할당합니다.이것은 var 사용과 비슷하지만 가져온 심볼의 타입과 네임스페이스 의미에 대해서도 작용합니다.중요한 점은, 값의 경우 import는 원래 심볼과 별개의 참조이므로 앨리어싱된 var에 대한 변경 사항은 원래 변수에 반영되지 않습니다.\n다른 JavaScript 라이브러리로 작업하기 (Working with Other JavaScript Libraries)\nTypeScript에서 작성되지 않은 라이브러리의 형태을 설명하려면 라이브러리에서 표시하는 API를 선언해야 합니다.대부분의 JavaScript 라이브러리는 몇 개의 최상위 레벨의 객체만 노출하므로 네임스페이스는 객체를 표현할 수있는 좋은 방법입니다.\n구현을 \"ambient\"으로 정의하지 않는 선언을 호출합니다.일반적으로 이들은 .d.ts 파일에 정의되어 있습니다.C/C++에 익숙하다면 .d.ts 파일로 생각할 수 있습니다.몇 가지 예를 살펴보겠습니다.\nAmbient Namespaces\n인기 있는 라이브러리 D3는 d3이라는 전역 객체에서 기능을 정의합니다.이 라이브러리는  태그 (모듈 로더 대신)를 통해 로드되기 때문에 선언에 네임스페이스를 사용하여 그 형태을 정의합니다.TypeScript 컴파일러가 이 형태을 보려면 ambient 네임스페이스 선언을 사용합니다.\n예를 들어 다음과 같이 작성할 수 있습니다:\nD3.d.ts (simplified excerpt)\ndeclare namespace D3 {\n    export interface Selectors {\n        select: {\n            (selector: string): Selection;\n            (element: EventTarget): Selection;\n        };\n    }\n\n    export interface Event {\n        x: number;\n        y: number;\n    }\n\n    export interface Base extends Selectors {\n        event: Event;\n    }\n}\n\ndeclare var d3: D3.Base;\n\n"},"pages/Namespaces and Modules.html":{"url":"pages/Namespaces and Modules.html","title":"네임스페이스와 모듈","keywords":"","body":"\n용어에 대한 참고 사항:\nTypeScript 1.5에 명칭이 변경되었습니다.\"내부 모듈\"은 이제 \"네임스페이스\"입니다.\"외부 모듈\"은 ECMAScript 2015의 용어에 맞게 간단히 \"모듈\"입니다 (즉 모듈 X { 는 현재 선호되는 네임스페이스 X { 와 동일합니다).\n\n소개\n이 게시물은 TypeScript의 네임스페이스와 모듈을 사용하여 구성하는 다양한 방법을 설명합니다.또한 네임스페이스와 모듈을 사용하는 방법에 대한 몇 가지 고급 주제를 살펴보고 TypeScript에서 사용할 때 일반적인 몇 가지 함정을 다룰 예정입니다.\n모듈에 대한 자세한 내용은 모듈의 문서를 참조하세요.네임스페이스에 대한 자세한 내용은 네임스페이스의 문서를 참조하세요.\n네임스페이스 사용하기 (Using Namespaces)\n네임스페이스는 전역 네임스페이스에서 JavaScript 객체로 불립니다.네임스페이스를 매우 사용하기 간단한 구조로 만듭니다.여러 파일에 걸쳐있을 수 있으며 --outFile을 사용하여 연결될 수 있습니다.네임스페이스는 HTML 페이지에  태그로 포 된 모든 의존성을 가진 웹 애플리케이션에서 코드를 구조화하는 좋은 방법이 될 수 있습니다.\n모든 전역 네임스페이스 오염과 마찬가지로, 특히 대규모 애플리케이션에서는 구성 요소 의존성을 식별하기 어려울 수 있습니다.\n모듈 사용하기 (Using Modules)\n네임 스페이스와 마찬가지로 모듈에는 코드와 선언을 모두 포함시킵니다.가장 큰 차이점은 모듈이 의존성을 선언한다는 것입니다.\n모듈은 또한 모듈 로더에 대한 의존성을 가지고 있습니다 (예: CommonJs/Require.js)작은 JS 애플리케이션의 경우는 최적이 아닐 수도 있지만 대규모 애플리케이션의 경우 장기적인 모듈성 및 유지 관리에 이점이 있습니다.모듈은 더 나은 코드 재사용, 강력한 격리 및 번들링을 위한 향상된 도구 지원을 제공합니다.\n또한 Node.js 애플리케이션의 경우 모듈이 기본이며 코드를 구조화하기 위한 권장 방법임을 유의해야 합니다.\nECMAScript 2015 부터는 모듈은 언어의 기본 요소이며 모든 호환 엔진 구현에서 지원해야 합니다.따라서 새로운 프로젝트의 경우 모듈이 코드 구성 메커니즘의 권장 사항이 됩니다.\n네임스페이스와 모듈의 위험 (Pitfalls of Namespaces and Modules)\n이 섹션에서는 네임스페이스와 모듈을 사용할 때 흔히 발생하는 다양한 위험에 대해 설명하고 이를 피하는 방법에 대해 알아보겠습니다.\n/// -ing a module\n일반적인 실수는 import 문을 사용하는 대신 모듈 파일을 참조하기 위해 ///  문을 사용하는 것이다.차이점을 이해하기 위해서는, 우선 컴파일러가 import(예:'...'에서 '...',import x from \"...\";에서 import x = require(\"...\"); 경로를 기반으로 모듈에 대한 타입 정보를 찾는 방법을 먼저 이해할 필요가 있습니다.\n컴파일러는 적절한 경로로 .ts, .tsx 그리고.d.ts를 찾으려 할 겁니다.특정 파일을 찾을 수 없으면 컴파일러는 ambient 모듈 선언을 찾습니다.이 파일들을 .d.ts 파일에 선언해야 한다는 것을 기억해야 합니다.\n\nmyModules.d.ts\n// 모듈이 아닌 .d.ts 파일 또는 .ts 파일:\ndeclare module \"SomeModule\" {\n    export function fn(): string;\n}\n\n\nmyOtherModule.ts\n/// \nimport * as m from \"SomeModule\";\n\n\n\n여기서 참조 태그는 ambient 모듈에 대한 선언을 포함하는 선언 파일을 찾을 수 있게 해줍니다.이것은 다수의 TypeScript 샘플에서 사용되는 node.d.ts 파일이 사용되는 방법입니다.\n불필요한 네임스페이스 (Needless Namespacing)\n프로그램을 네임스페이스에서 모듈로 변환하는 경우에는 다음과 파일로 같은 쉽게 끝날 수 있습니다:\n\nshapes.ts\nexport namespace Shapes {\n    export class Triangle { /* ... */ }\n    export class Square { /* ... */ }\n}\n\n\n\n여기 최상위 모듈인 Shapes은 Triangle과 Square를 감싸고 있는 데 아무런 이유가 없습니다.이는 모듈의 사용자들을 혼란스럽고 성가시게 합니다:\n\nshapeConsumer.ts\nimport * as shapes from \"./shapes\";\nlet t = new shapes.Shapes.Triangle(); // shapes.Shapes?\n\n\n\nTypeScript에서 모듈의 주요 특징은 두 개의 서로 다른 모듈이 동일한 스코프에 이름을 제공하지 않는다는 것입니다.모듈의 사용자가 할당할 이름을 결정하기 때문에 네임스페이스에서 내보낸 심볼을 사전에 감쌀 필요가 없습니다.\n모듈 내용의 네임스페이스를 지정하지 않아야 하는 이유를 반복해서 설명하기 위해 Namespacing은 구조의 논리적 그룹을 제공하고 이름 충돌을 방지하는 것입니다.모듈 파일 자체는 논리적 그룹이며 최상위 이름은 이를 가져오는 코드에 의해 정의되기 때문에 내보낸 객체에 대해 추가적인 모듈 계층을 사용할 필요가 없습니다.\n다음은 수정된 예입니다.\n\nshapes.ts\nexport class Triangle { /* ... */ }\nexport class Square { /* ... */ }\n\n\nshapeConsumer.ts\nimport * as shapes from \"./shapes\";\nlet t = new shapes.Triangle();\n\n\n\n모듈의 관계 (Trade-offs of Modules)\nJS 파일과 모듈 사이에 일대일 대응이 있는 것과 마찬가지로 TypeScript는 모듈 소스 파일과 방출된 JS 파일 간에 일대일 대응을 합니다.이에 따른 한가지 효과는 대상 모듈 시스템에 따라 여러 모듈 소스 파일을 연결할 수 없다는 것입니다.예를 들어 commonjs 또는 umd를 대상으로 하는 동안 outFile 옵션을 사용할 수 없지만 TypeScript 1.8 이상에서는 amd 또는 system을 대상으로 지정할 때 outFile을 사용할 수 있습니다.\n"},"pages/Module Resolution.html":{"url":"pages/Module Resolution.html","title":"모듈 해석","keywords":"","body":"\n이번 섹션에서는 모듈에 대한 몇 가지 기본 지식을 전제로합니다. 자세한 내용은 모듈을 참조하세요.\n\n모듈 resolution은 import가 무엇을 참조하는지 파악하기 위해 컴파일러가 사용하는 프로세스입니다.import { a } from \"moduleA\"와 같은 import 문을 고려하세요.  \na의 사용을 검사하기 위해서는 컴파일러는 그것이 무엇을 의미하는지 정확히 알아야 하며 그것의 정의인 moduleA를 검사해야 할 필요가 있습니다.\n이때 컴파일러가 \"moduleA의 형태가 무엇입니까?\"라고 묻습니다.이것은 간단하게 들릴지 모르지만 moduleA는 자신의 .ts/.tsx 파일들 중 하나 또는 사용자의 코드가 의존하는 .d.ts 파일 중 하나에서 정의될 수 있습니다.\n먼저 컴파일러는 가져온 모듈을 나타내는 파일을 찾습니다.이렇게하기 위해 컴파일러는 다음 두 가지 전략 중 하나를 따릅니다: 클래식 또는 노드.이 전략은 컴파일러에게 moduleA를 찾을 위치를 알려줍니다.\n그래도 작동하지 않고 모듈 이름이 관련이 없는 경우(\"moduleA\"의 경우에는)  컴파일러는 ambient module declaration을 찾으려고 시도할 것입니다.다음에 Non-relative imports에 대해 다룰 것입니다.\n마지막으로 컴파일러가 모듈을 해석하지 못하면 오류를 기록합니다.이 경우 오류는 오류 TS2307 : 모듈 'moduleA'을 찾을 수 없습니다.\n상대적 vs. 비-상대적 모듈 import (Relative vs. Non-relative module imports)\n모듈 imports는 모듈 참조가 상대적인지 아닌지에 따라 다르게 처리됩니다.\nrelative import는 /, ./ 또는 ../ 로 시작하는 임포트입니다.몇 가지 예는 다음과 같습니다:\n\nimport Entry from \"./components/Entry\";\nimport { DefaultHeaders } from \"../constants/http\";\nimport \"/mod\";\n\n다른 모든 import는 non-relative로 간주됩니다.몇 가지 예는 다음과 같습니다:\n\nimport * as $ from \"jquery\";\nimport { Component } from \"@angular/core\";\n\nimport된 파일과 관련하여 relative import가 해석되었으며 ambient module declaration에 으로 해석할 수는 없습니다.상대적인 위치를 런타임에 유지할 수 있도록 보장되는 모듈에 relative imports를 사용해야 합니다.\nnon-relative import는 baseUrl을 기준 또는 경로 매핑을 통해 해석될 수 있습니다.또한 ambient module declarations으로 해석할 수도 있습니다.외부의 의존성을 가져올 때는 non-relative 경로를 사용하세요.\n모듈 해석 전략 (Module Resolution Strategies)\n모듈 해석 전략에는 두가지가 있습니다: 노드와 클래식.--moduleResolution를 사용하여 모듈 해석 전략을 지정할 수 있습니다.지정하지 않은 경우 기본값은 --module AMD | System | ES2015인 경우 클래식이며 그렇지 않다면 노드입니다.\n클래식 (Classic)\n이것은 TypeScript의 기본 해석 전략이었습니다.요즘은 주로 이전 버전과의 호환성을 위해 이 전략이 존재합니다.\nrelative import는 import된 파일과 관련하여 해석됩니다.그러므로 소스 파일 /root/src/folder/A.ts에 있는 import { b } from \"./moduleB\"를 실행하면 다음과 같은 결과가 나옵니다:\n\n/root/src/folder/moduleB.ts\n/root/src/folder/moduleB.d.ts\n\n그러나 non-relative 모듈 imports의 경우 컴파일러는 imports 파일이 포함된 디렉토리부터 시작하여 일치하는 정의 파일을 가져오기 위해 디렉토리 트리를 찾으려합니다.\n예를 들어:\nmoduleB를 소스 파일에서 import { b } from \"moduleB\"와 같이 상대적으로 가져오지 않으면 \"moduleB\"를 찾기 위해 다음과 같은 위치에서 찾게 됩니다:\n\n/root/src/folder/moduleB.ts\n/root/src/folder/moduleB.d.ts\n/root/src/moduleB.ts\n/root/src/moduleB.d.ts\n/root/moduleB.ts\n/root/moduleB.d.ts\n/moduleB.ts\n/moduleB.d.ts\n\n노드 (Node)\n이 해석 전략은 런타임에 Node.js 모듈 분석 메커니즘을 모방하려고 시도합니다.전체 Node.js 해석 알고리즘은 Node.js 모듈 문서에 설명되어 있습니다.\nNode.js 모듈 해석 방법 (How Node.js resolves modules)\nTS 컴파일러가 따르는 단계를 이해하려면 Node.js 모듈에 대해 설명하는 것이 중요합니다.전통적으로, Node.js의 import는 require라는 함수를 호출함으로써 수행됩니다.Node.js가 취하는 동작은 require에 상대 경로인지 비-상대 경로인지에 따라 달라집니다.\n상대 경로는 매우 간단합니다.예를 들어 var x = require(\"./moduleB\"); import가 포함된 /root/src/moduleA.js에 있는 파일을 살펴보겠습니다.Node.js는 가져 오기를 다음 순서로 해석합니다:\n\n/root/src/moduleB.js라는 이름의 파일이 존재합니다.\n\n\"main\" 모듈을 지정하는 package.json 파일이 포함된 경우 /root/src/moduleB 폴더로 지정합니다.이 예에서, Node.js가 { \"main\": \"lib/mainModule.js\" }를 포함하는 /root/src/moduleB/package.json 파일을 찾으면 Node.js는 /root/src/moduleB/lib/mainModule.js를 참조합니다.\n\nindex.js라는 파일이 포함되어 있다면 /root/src/moduleB 폴더로 간주합니다.그 파일은 암시적으로 그 폴더의 \"메인\" 모듈로 여겨집니다.\n\n\n이에 대한 자세한 내용은 파일 모듈과 폴더 모듈에 대한 Node.js 문서를 참조하세요.\n그러나 non-relative module name의 해석은 다르게 수행됩니다.node는 node_modules라는 특수 폴더에서 모듈을 검색합니다.node_modules 폴더는 현재 파일과 동일한 레벨이거나 디렉토리 체인에서 상위 레벨 일 수 있습니다.node는 불러오기 위한 모듈을 찾을 때까지 각 node_modules를 보고 디렉토리 체인을 거슬러 올라갑니다.\n위의 예제를 따르면, /root/src/moduleA.js가 비-상대 경로를 대신 사용하여 var x = require(\"moduleB\"); import를 가지고 있는지 고려해보세요.\n그런 다음 Node는 moduleB가 작동할 때까지 각 위치에 대해 해석을 시도합니다.\n\n/root/src/node_modules/moduleB.js\n/root/src/node_modules/moduleB/package.json (\"main\" 프로퍼티 지정)\n/root/src/node_modules/moduleB/index.js\n\n/root/node_modules/moduleB.js\n/root/node_modules/moduleB/package.json (\"main\" 프로퍼티 지정)\n/root/node_modules/moduleB/index.js\n\n/node_modules/moduleB.js\n/node_modules/moduleB/package.json (\"main\" 프로퍼티 지정)\n/node_modules/moduleB/index.js\n\nNode.js가 (4)와 (7)에서 디렉토리 이동했음을 주목하세요.\n이 프로세스에 대한 자세한 내용은 node_modules에서 모듈을 로드하는 방법에 대한 node.js 문서를 참조하세요.\nTypeScript 모듈 해석 방법 (How TypeScript resolves modules)\nTypeScript는 컴파일 타임에 모듈에 대한 정의 파일을 찾기 위해 Node.js 런타임 해석 전략을 모방합니다.이를 달성하기 위해 TypeScript는 TypeScript 원본 파일 확장자 (.ts, .tsx, 및 .d.ts)을 노드의 해석 로직 위에 덮어씌웁니다.TypeScript는 또한 \"main\"의 목적을 반영하기 위해 package.json에 있는 `types\" 필드를 사용합니다 - 컴파일러가 이를 사용하여 참조할 \"main\" 정의 파일을 찾습니다.\n예를 들어 /root/src/moduleA.ts에서 import { b } from \"./moduleB\"와 같은 import 문은 \"./moduleB\"를 찾기 위해 다음 위치에서 시도하게됩니다:\n\n/root/src/moduleB.ts\n/root/src/moduleB.tsx\n/root/src/moduleB.d.ts\n/root/src/moduleB/package.json (\"types\" 프로퍼티 지정)\n/root/src/moduleB/index.ts\n/root/src/moduleB/index.tsx\n/root/src/moduleB/index.d.ts\n\nNode.js는 moduleB.js 파일을 찾은 다음, 적용 가능한 package.json 파일을 찾아 index.js 파일을 찾습니다.\n마찬가지로 비-상대적인 import에서는 Node.js 해석 로직을 따르고 먼저 파일을 검색한 다음 적용 가능한 폴더를 찾습니다.따라서 소스 파일 /root/src/moduleA.ts에서  import { b } from \"moduleB\"는 다음과 같은 조회를 하게 됩니다:\n\n/root/src/node_modules/moduleB.ts\n/root/src/node_modules/moduleB.tsx\n/root/src/node_modules/moduleB.d.ts\n/root/src/node_modules/moduleB/package.json (\"types\" 프로퍼티 지정)\n/root/src/node_modules/moduleB/index.ts\n/root/src/node_modules/moduleB/index.tsx\n/root/src/node_modules/moduleB/index.d.ts\n\n/root/node_modules/moduleB.ts\n/root/node_modules/moduleB.tsx\n/root/node_modules/moduleB.d.ts\n/root/node_modules/moduleB/package.json (\"types\" 프로퍼티 지정)\n/root/node_modules/moduleB/index.ts\n/root/node_modules/moduleB/index.tsx\n/root/node_modules/moduleB/index.d.ts\n\n/node_modules/moduleB.ts\n/node_modules/moduleB.tsx\n/node_modules/moduleB.d.ts\n/node_modules/moduleB/package.json (\"types\" 프로퍼티 지정)\n/node_modules/moduleB/index.ts\n/node_modules/moduleB/index.tsx\n/node_modules/moduleB/index.d.ts\n\n단계의 수에 겁먹지마세요 - TypeScript는 여전히 단계 (8)과 (15)에서 디렉토리를 두 번 점프합니다.이것은 정말로 Node.js보다 복잡하지 않습니다.\n추가적인 모듈 해석 알리기 (Additional module resolution flags)\n프로젝트 소스 레이아웃이 출력 결과와 일치하지 않는 경우가 있습니다.일반적으로 일련의 빌드 단계의 집합에서 최종 출력을 생성합니다.여기에는 .ts 파일을 .js로 컴파일하는 것과 다른 소스 위치의 의존성을 하나의 출력 위치에 복사하는 것이 포함됩니다.최종적으로 런타임에 모듈의 이름이 정의를 포함하는 소스 파일과 다를 수 있다는 것입니다.또는 최종 출력의 모듈 경로가 컴파일 시 해당 소스 파일 경로와 일치하지 않을 수 있습니다.\nTypeScript 컴파일러에는 최종 출력을 생성하기 위해 소스에 발생할 것으로 예상되는 변환의 컴파일러에 정보를 제공하기 위한 추가적인 것들이 있습니다.\n컴파일러가 이러한 변환을 하지 않을 것을 주목하는 것이 중요합니다.이 정보를 사용하여 모듈 import를 정의 파일로 해석하는 프로세스를 안내합니다.\nBase URL\nbaseUrl을 사용하는 것은 모듈이 런타임에 단일 폴더로 \"배포\"되는 AMD 모듈 로더를 사용하는 어플리케이션에서의 일반적인 방법입니다.이러한 모듈의 소스는 서로 다른 디렉토리에 존재할 수 있지만 빌드 스크립트에 의해 모두 결합되어 구성됩니다. \nbaseUrl을 설정하면 컴파일러에게 어디에서 모듈을 찾을 수 있는지 알려줍니다.비-상대적 이름을 가진 모든 모듈 imports는 baseUrl에 상대적인 것으로 가정됩니다.\nbaseUrl 값은 다음 중 하나로 결정됩니다:\n\nbaseUrl 커멘드 라인 인수의 값 (주어진 경로가 상대 경로인 경우 현재의 디렉토리의 위치를 기반으로 계산)\n'tsconfig.json'의 baseUrl 프로퍼티 값 (주어진 경로가 상대 경로인 경우 'tsconfig.json'의 위치를 기반으로 계산)\n\n상대적 모듈 imports는 baseUrl을 설정하면 영향을 받지 않으며 imports 파일과 관련하여 항상 확인되므로 주의해야합니다.\nRequireJS 및 SystemJS 문서에서 baseUrl에 대한 자세한 설명을 볼 수 있습니다.\n경로 매핑 (Path mapping)\n때때로 모듈은 baseUrl 아래에 직접 위치하지 않습니다.예를 들어, 모듈 \"jquery\"에 대한 import는 런타임시에 \"node_modules/jquery/dist/jquery.slim.min.js\"로 변환됩니다.로더는 매핑 구성을 사용하여 런타임에 모듈 이름을 파일에 매핑 합니다. 자세한 내용은 RequireJs 문서와 SystemJS 문서를 참조하세요.  \nTypeScript 컴파일러는 tsconfig.json파일에서 \"paths\" 프로퍼티를  사용하여 이러한 매핑을 선언하는 기능을 지원합니다.다음은 jquery에 대한 \"paths\" 프로퍼티를 지정하는 예제입니다.\n{\n  \"compilerOptions\": {\n    \"baseUrl\": \".\", // \"paths\"가 지정된 경우 이 값을 지정해야합니다.\n    \"paths\": {\n      \"jquery\": [\"node_modules/jquery/dist/jquery\"] // 이 매핑은 \"baseUrl\"과 상대적입니다.\n    }\n  }\n}\n\n\"paths\"는 \"baseUrl\"에 비례해서 해석된다는 것을 주의하십시오.\"baseUrl\"을 \".\"보다 다른 값으로 설정할 때 즉 tsconfig.json의 디렉토리일때마다 매핑을 적절하게 변경해야합니다.가령 위의 예제에서 \"baseUrl\": \"./src\"를 설정하면 jquery는 \"../node_modules/jquery/dist/jquery\"에 매핑되어야합니다.\n\"paths\"를 사용하면 여러개의 fall back 위치를 포함한 좀 더 정교한 매핑을 사용할 수도 있습니다.한 위치에서는 일부 모듈만 사용할 수 있고 나머지는 다른 위치에 있는 프로젝트 구성을 고려해보세요.빌드 단계는 모든 것을 한 곳에 한 곳에 모일 것입니다.  \n프로젝트 레이아웃은 다음과 같을 수 있습니다:\nprojectRoot\n├── folder1\n│   ├── file1.ts (imports 'folder1/file2' and 'folder2/file3')\n│   └── file2.ts\n├── generated\n│   ├── folder1\n│   └── folder2\n│       └── file3.ts\n└── tsconfig.json\n\n해당 tsconfig.json은 다음과 같습니다:\n{\n  \"compilerOptions\": {\n    \"baseUrl\": \".\",\n    \"paths\": {\n      \"*\": [\n        \"*\",\n        \"generated/*\"\n      ]\n    }\n  }\n}\n\n이것은 \"*\"(모든 값) 패턴과 일치하는 모듈 import를 컴파일러에게 알려줌으로써 두 위치를 살펴봅니다:\n\n\"*\": 변경되지 않은 동일한 이름을 의미하기때문에  => /을 매핑하세요.\n\"generated/*\" 추가된 접두어 \"generated\"가 붙은 모듈 이름을 의미하기때문에  => /generated/을 매핑하세요.\n\n이 로직에 따라 컴파일러는 두 가지 imports를 다음과 같이 해석하기위해 노력합니다:\n\nimport 'folder1/file2'\n'*' 패턴이 일치하고 와일드 카드가 전체 모듈 이름을 캡처합니다.\n먼저 목록에 대체를 시도하세요: '*' -> folder1/file2\n이에 따른 대체 결과는 비상대적인 이름입니다 - baseUrl 와 결합하세요 -> projectRoot/folder1/file2.ts.\n좋아요. 파일이 존재합니다.\n\n\nimport 'folder2/file3'\n'*' 패턴이 일치하고 와일드 카드가 전체 모듈 이름을 캡처합니다.\n먼저 목록에 대체를 시도하세요: '*' -> folder2/file3\n이에 따른 대체 결과는 비-상대적인 이름입니다 - baseUrl 와 결합하세요 -> projectRoot/folder2/file3.ts.\n파일이 존재하지 않습니다. 두번째 대체 파일로 이동하세요.\n두번째 대체 'generated/*' -> generated/folder2/file3\n이에 따른 대체 결과는 비-상대적인 이름입니다 - baseUrl 와 결합하세요 -> projectRoot/generated/folder2/file3.ts.\n좋아요. 파일이 존재합니다.\n\n\n\nrootDirs 디렉토리 (Virtual Directories with rootDirs)\n컴파일 시 여러 디렉토리의 프로젝트 소스가 모두 결합되어 단일 출력 디렉토리를 생성하는 경우가 있습니다.이것은 소스 디렉토리가 \"가상\" 디렉토리를 만드는 것으로 볼 수 있습니다.\nrootDirs를 사용하면 \"가상\" 디렉토리를 구성하는 roots를 컴파일러에 알릴 수 있습니다.따라서 컴파일러는 이러한 \"가상\" 디렉토리내의 상대 모듈 imports를 하나의 디렉토리에 병합된 것처럼 해석 할 수 있습니다.\n예를 들어 다음 프로젝트 구조를 고려해보세요.\n src\n └── views\n     └── view1.ts (imports './template1')\n     └── view2.ts\n\n generated\n └── templates\n         └── views\n             └── template1.ts (imports './view2')\n\nsrc/views의 파일은 일부 UI컨트롤의 사용자 코드입니다.generated/templates 파일은 빌드의 일부로 템플릿 생성기에 의해 자동 생성된 UI템플릿 바인딩 코드입니다.빌드 단계는 /src/views 및 /generated/templates/views에 있는 파일을 출력의 동일한 디렉토리에 복사합니다.런타임에 뷰는 템플릿이 그 옆에 존재하기를 기대할 수 있으므로 상대적 이름을 \"./template\"로 사용하여 import합니다.\n이 관계를 컴파일러에 지정하려면 \"rootDirs\"를 사용하세요.\"rootDirs\"은 내용이 런타임에 병합될 것으로 예상되는 roots 목록을 지정합니다.따라서 우리의 예에 따라, tsconfig.json파일은 다음과 같이 보여야 합니다:\n{\n  \"compilerOptions\": {\n    \"rootDirs\": [\n      \"src/views\",\n      \"generated/templates/views\"\n    ]\n  }\n}\n\n컴파일러가 rootDirs의 하위 폴더에 있는 상대적 모듈 가져오기를 볼 때마다 rootDirs의 각 항목에서 import를 검색합니다.\nrootDirs의 유연성은 논리적으로 병합된 물리적 소스 디렉토리 목록 지정에 한정되는 것은 아닙니다.제공된 배열은 존재 여부에 관계 없이 원하는 수의 임의 디렉토리 이름을 포함할 수 있습니다.이를 통해 컴파일러는 조건부 포함 및 프로젝트 별 로더 플러그인과 같은 정교한 번들 및 런타임 기능을 타입 세이프 방식으로 캡처할 수 있습니다.\n빌드 도구가 ./#{locale}/messages와 같은 상대 모듈 경로의 일부로써 특별한 경로 토큰 #{locale}을 삽입하여 지역 특정 번들을 자동으로 생성하는 국제화 시나리오를 생각해보세요.  \n이 가상 설정에서 도구는 지원되는 로케일을 열거하고 추상화된 경로를 ./zh/messages, ./de/messages 등으로 매핑합니다.  \n이러한 각 모듈이 일련의 문자열을 내보낸다고 가정합니다.예를 들어 ./zh/messages에는 다음이 포함될 수 있습니다:\nexport default [\n    \"您好吗\",\n    \"很高兴认识你\"\n];\n\nrootDirs를 활용하여 디렉토리가 존재하지 않더라도 이 매핑의 컴파일러에 이를 알려 줌으로써 ./#{locale}/messages를 안전하게 해결할 수 있습니다.\n예를 들어, 다음과 같은 tsconfig.json을 함께 사용합니다:\n{\n  \"compilerOptions\": {\n    \"rootDirs\": [\n      \"src/zh\",\n      \"src/de\",\n      \"src/#{locale}\"\n    ]\n  }\n}\n\n이제 컴파일러는 import messages from './#{locale}/messages'에서 import messages from './zh/messages'의 메시지를 가져 와서 시간 지원 계획을 해치지 않고 지역에 상관없이 개발할 수 있습니다.\n모듈 해석 추적 (Tracing module resolution)\n앞에서 설명한 것처럼 컴파일러가 모듈을 해석할 때 현재 폴더 외부의 파일들에 방문할 수 있습니다.모듈이 해석되지 않은 이유를 진단하거나 잘못된 정의로 해석된 경우에는  문제 해석이 어려울 수 있습니다.--traceResolution을 사용하여 컴파일러 모듈 해석 추적을 활성화하면 모듈 확인 프로세스 중에 발생한 일에 대한 통찰력을 얻을 수 있습니다.\ntypescript 모듈을 사용하는 샘플 애플리케이션이 있다고 가정해 봅시다.app.ts는 import * as ts from \"typescript\"와 같은 import를 가지고 있습니다.\n│   tsconfig.json\n├───node_modules\n│   └───typescript\n│       └───lib\n│               typescript.d.ts\n└───src\n        app.ts\n\n--traceResolution을 사용하여 컴파일러 호출하기\ntsc --traceResolution\n\n결과는 다음과 같습니다:\n======== Resolving module 'typescript' from 'src/app.ts'. ========\nModule resolution kind is not specified, using 'NodeJs'.\nLoading module 'typescript' from 'node_modules' folder.\nFile 'src/node_modules/typescript.ts' does not exist.\nFile 'src/node_modules/typescript.tsx' does not exist.\nFile 'src/node_modules/typescript.d.ts' does not exist.\nFile 'src/node_modules/typescript/package.json' does not exist.\nFile 'node_modules/typescript.ts' does not exist.\nFile 'node_modules/typescript.tsx' does not exist.\nFile 'node_modules/typescript.d.ts' does not exist.\nFound 'package.json' at 'node_modules/typescript/package.json'.\n'package.json' has 'types' field './lib/typescript.d.ts' that references 'node_modules/typescript/lib/typescript.d.ts'.\nFile 'node_modules/typescript/lib/typescript.d.ts' exist - use it as a module resolution result.\n======== Module name 'typescript' was successfully resolved to 'node_modules/typescript/lib/typescript.d.ts'. ========\n\n주의사항 (Things to look out for)\n\nimport의 이름과 위치\n\n======== 모듈 해석 'typescript' from 'src/app.ts'. ========\n\n\n컴파일러가 따르는 방법\n\n'NodeJs' 를 사용하여 모듈 해석 종류가 지정되지 않았습니다.\n\n\nnpm 패키지에서 타입 로드\n\n'package.json'에는 'node_modules/typescript/lib/typescript.d.ts'를 참조하는 'types' 필드인 './lib/typescript.d.ts'가 있습니다.\n\n\n최종 결과\n\n======== 모듈 이름 'typescript'는 'node_modules/typescript/lib/typescript.d.ts'에서 성공적으로 해석되었습니다. ========\n\n\n\n--noResolve 사용하기 (Using --noResolve)\n일반적으로 컴파일러는 컴파일 프로세스를 시작하기 전에 모든 모듈의 imports를 해석하려고 시도합니다.파일에 import를 성공적으로 해석할 때마다 컴파일러는 파일을 나중에 처리할 파일 집합에 추가합니다.\n--noResolve 컴파일러 옵션은 컴파일러가 커맨드라인에서 전달되지 않은 파일을 컴파일에 \"추가\"하지 않도록 지시합니다.모듈을 파일로 해석하려고 하지만 파일이 지정되지 않으면 포함되지 않습니다.\n예를 들어:\napp.ts\nimport * as A from \"moduleA\" // 좋아요, 'moduleA'가 커맨드라인에서 전달되었습니다.\nimport * as B from \"moduleB\" // TS2307 오류: 'moduleB' 모듈을 찾을 수 없습니다.\n\ntsc app.ts moduleA.ts --noResolve\n\n--noResolve를 사용하여 app.ts를 컴파일하면 다음과 같은 결과가 발생합니다:\n\n커맨드라인에서 전달된대로 moduleA를 적절하게 찾습니다.\n전달되지 않았기 때문에 moduleB를 찾지 못하는 오류.\n\n공통 질문 (Common Questions)\n제외 목록에 있는 모듈을 여전히 컴파일러가 선택하는 이유는 무엇입니까? (Why does a module in the exclude list still get picked up by the compiler?)\ntsconfig.json은 폴더를 \"프로젝트\"로 만듭니다.“exclude” 또는 “files” 항목을 지정하지 않으면 tsconfig.json을 포함한 폴더의 모든 파일과 해당 하위 디렉토리가 컴파일에 포함됩니다.일부 파일을 제외하려면 “exclude”를 사용하세요.만일 모든 파일을 지정하고 싶다면 컴파일러가 찾아보게 하는 대신에 “files”을 사용하세요.\ntsconfig.json는 자동 포함입니다.위에서 설명한 모듈 해석을 포함하지 않습니다.컴파일러가 파일을 모듈 import의 대상으로 식별하는 경우 이전 단계에서 제외되었는지 여부에 관계 없이 컴파일에 포함됩니다.\n따라서 컴파일에서 파일을 제외하려면 import 또는 ///  지시자가 있는 모든 파일을 제외해야 합니다.\n"},"pages/Declaration Merging.html":{"url":"pages/Declaration Merging.html","title":"선언 병합","keywords":"","body":"소개\nTypeScript의 고유한 개념 중 일부는 타입 레벨에서 JavaScript 객체의 형태를 설명합니다.특히 TypeScript에서의 고유한 예로는 '선언 병합'이라는 개념이 있습니다.이 개념을 이해하는 것은 기존 JavaScript를 사용할 때 이점을 제공할 것입니다.또한 고급 추상화 개념에 대한 문을 열어줍니다.\n이 아티클의 목적인 \"선언 병합\"은 컴파일러가 동일한 이름으로 선언된 두개의 독립된 선언을 하나의 정의로 병합하는 것을 의미합니다.이 병합된 정의에는 원래 선언의 두 가지 기능이 있습니다.어떠한 수의 선언이든 병합할 수 있습니다. 단지 두 가지 선언에 제한되지 않습니다.\n기본 개념 (Basic Concepts)\nTypeScript에서 선언은 다음 세 가지 중 하나 이상의 엔티티를 생성합니다: 네임스페이스, 타입 또는 값네임스페이스-생성 선언은 점 표기법을 사용하여 접근하는 이름이 포함된 네임스페이스를 생성합니다.타입-생성 선언은 다음과 같습니다: 선언된 형태로 표시되고 주어진 이름에 바인딩 되는 타입을 작성합니다.마지막으로, 값-생성 선언은 출력된 JavaScript에서 볼 수 있는 값을 만듭니다.\n\n\n\n선언 타입\n네임스페이스\n타입\n값\n\n\n\n\n네임스페이스\nX\n\nX\n\n\n클래스\n\nX\nX\n\n\n열거형\n\nX\nX\n\n\n인터페이스\n\nX\n\n\n\n타입 별칭\n\nX\n\n\n\n함수\n\n\nX\n\n\n변수\n\n\nX\n\n\n\n각 선언으로 생성된 내용을 이해하면 선언 병합을 수행할 때 병합되는 내용을 이해하는 데 도움이 됩니다.\n인터페이스 병합 (Merging Interfaces)\n가장 단순하고 아마도 가장 일반적인 타입의 선언 병합은 인터페이스 병합입니다.가장 기본적인 수준에서 이 병합은 두 선언의 멤버를 기계적으로 같은 이름의 단일 인터페이스에 결합합니다.\ninterface Box {\n    height: number;\n    width: number;\n}\n\ninterface Box {\n    scale: number;\n}\n\nlet box: Box = {height: 5, width: 6, scale: 10};\n\n인터페이스의 비-함수 멤버는 고유해야 합니다.고유하지 않다면 같은 타입이어야 합니다.컴파일러는 인터페이스가 모두 같은 이름이지만 다른 타입의 비-함수 멤버를 선언하는 경우 오류를 발생시킵니다.\n함수 멤버의 경우 같은 이름의 각 함수 멤버가 같은 함수의 오버로드를 설명하는 것으로 간주합니다.또한 후위의 인터페이스 A와 인터페이스 A를 병합하는 경우에는 두 번째 인터페이스가 첫 번째 인터페이스보다 우선순위가 더 높다는 점이 주목됩니다.\n예를 들어 다음과 같습니다:\ninterface Cloner {\n    clone(animal: Animal): Animal;\n}\n\ninterface Cloner {\n    clone(animal: Sheep): Sheep;\n}\n\ninterface Cloner {\n    clone(animal: Dog): Dog;\n    clone(animal: Cat): Cat;\n}\n\n세 개의 인터페이스가 병합되어 단일 선언을 생성합니다:\ninterface Cloner {\n    clone(animal: Dog): Dog;\n    clone(animal: Cat): Cat;\n    clone(animal: Sheep): Sheep;\n    clone(animal: Animal): Animal;\n}\n\n각 그룹의 요소는 같은 순서를 유지하지만 그룹 자체는 나중에 오버로드가 발생한 것이 가장 먼저 병합됩니다.\n이 규칙에 대한 한가지 예외는 특수한 시그니처(specialized signatures)입니다.시그니처의 타입이 단일 문자열 리터럴 타입(예 : 문자열 리터럴의 유니온이 아닌)인 매개 변수가 있는 경우 병합된 오버로드 목록의 맨 위로 버블링됩니다.\n예를 들어 다음 인터페이스가 함께 병합됩니다:\ninterface Document {\n    createElement(tagName: any): Element;\n}\ninterface Document {\n    createElement(tagName: \"div\"): HTMLDivElement;\n    createElement(tagName: \"span\"): HTMLSpanElement;\n}\ninterface Document {\n    createElement(tagName: string): HTMLElement;\n    createElement(tagName: \"canvas\"): HTMLCanvasElement;\n}\n\nDocument의 병합된 선언은 다음과 같습니다:\ninterface Document {\n    createElement(tagName: \"canvas\"): HTMLCanvasElement;\n    createElement(tagName: \"div\"): HTMLDivElement;\n    createElement(tagName: \"span\"): HTMLSpanElement;\n    createElement(tagName: string): HTMLElement;\n    createElement(tagName: any): Element;\n}\n\n네임스페이스 병합 (Merging Namespaces)\n인터페이스와 마찬가지로 같은 이름의 네임 스페이스도 해당 멤버를 병합합니다.네임 스페이스는 네임 스페이스와 값을 모두 생성하기 때문에 두 네임 스페이스가 어떻게 병합되는지 이해해야 합니다.\n네임 스페이스를 병합하기 위해 각 네임스페이스에 선언된 exported 인터페이스의 타입 정의 자체가 병합되며 내부에 병합된 인터페이스 정의가 있는 단일 네임스페이스를 형성합니다.\n네임 스페이스 값을 병합하려면 각 선언 사이트에 지정된 이름의 네임 스페이스가 이미 있는 경우 기존 네임 스페이스를 가져와 두 번째 네임 스페이스의 내보낸 멤버를 첫 번째 네임스페이스에 추가하여 네임 스페이스를 확장합니다.\n이 예에서는 Animals의 병합을 선언합니다:\nnamespace Animals {\n    export class Zebra { }\n}\n\nnamespace Animals {\n    export interface Legged { numberOfLegs: number; }\n    export class Dog { }\n}\n\n다음과 같습니다.\nnamespace Animals {\n    export interface Legged { numberOfLegs: number; }\n\n    export class Zebra { }\n    export class Dog { }\n}\n\n병합된 네임스페이스의 모델은 유용한 출발점이지만 내보내지 않은(non-exported) 멤버에 무슨 일이 일어나는지 이해할 필요가 있습니다.내보낼 수 없는 멤버는 원래 (병합되지 않은) 네임 스페이스에서만 볼 수 있습니다.즉 병합 후에는 다른 선언에서 가져온 병합된 멤버는 내보낼 수 없는 멤버를 볼 수 없습니다.\n내보내지 않은 멤버는 원래 네임스페이스에서만 볼 수 있습니다(병합되지 않음).즉 병합 후에 다른 선언에서 가져온 병합된 멤버는 내보내지 않은 멤버를 볼 수 없습니다.\n이 예제에서 이것을 더 명확하게 볼 수 있습니다:\nnamespace Animal {\n    let haveMuscles = true;\n\n    export function animalsHaveMuscles() {\n        return haveMuscles;\n    }\n}\n\nnamespace Animal {\n    export function doAnimalsHaveMuscles() {\n        return haveMuscles;  // \nhaveMuscles가 exported되지 않았기 때문에 동일하게 병합되지 않은 네임스페이스를 공유하는 animalsHaveMuscles 함수만 이 심볼을 볼 수 있습니다.doAnimalsHaveMuscles 함수는 병합된 Animal 네임스페이스의 일부임에도 불구하고 exported 되지 않은 멤버를 볼 수 없습니다.\n클래스, 함수 그리고 열거형 병합 (Merging Namespaces with Classes, Functions, and Enums)\n네임스페이스는 다른 타입의 선언과도 통합이 가능할 정도로 유연합니다.이렇게 하려면 네임스페이스 선언이 병합할 선언을 따라야 합니다.결과 선언에는 두 선언 타입의 프로퍼티가 있습니다.TypeScript는 이 기능을 사용하여 JavaScript의 일부 패턴과 다른 프로그래밍 언어를 모델링 합니다.\n클래스와 네임스페이스 병합 (Merging Namespaces with Classes)\n이는 사용자에게 내부(inner) 클래스를 설명하는 방법을 제공합니다.\nclass Album {\n    label: Album.AlbumLabel;\n}\nnamespace Album {\n    export class AlbumLabel { }\n}\n\n병합된 멤버의 가시성 규칙은 '네임스페이스 병합' 섹션에 설명된 것과 같으므로 병합된 클래스를 보려면 AlbumLabel 클래스를 export 해야 합니다.최종 결과는 다른 클래스 내부에서 관리되는 클래스입니다.네임스페이스를 사용하여 기존 클래스에 더 많은 정적 멤버를 추가할 수도 있습니다.\n내부 클래스 패턴 외에도 함수를 생성한 다음 함수에 프로퍼티를 추가하여 함수를 확장하는 JavaScript 방법에 익숙할 수도 있습니다.TypeScript는 이러한 타입을 안전한(type-safe) 방법으로 정의하기 위해 선언 병합을 사용합니다.\nfunction buildLabel(name: string): string {\n    return buildLabel.prefix + name + buildLabel.suffix;\n}\n\nnamespace buildLabel {\n    export let suffix = \"\";\n    export let prefix = \"Hello, \";\n}\n\nalert(buildLabel(\"Sam Smith\"));\n\n마찬가지로 네임스페이스를 사용하여 정적 멤버를 포함하는 열거형을 확장할 수 있습니다:\nenum Color {\n    red = 1,\n    green = 2,\n    blue = 4\n}\n\nnamespace Color {\n    export function mixColor(colorName: string) {\n        if (colorName == \"yellow\") {\n            return Color.red + Color.green;\n        }\n        else if (colorName == \"white\") {\n            return Color.red + Color.green + Color.blue;\n        }\n        else if (colorName == \"magenta\") {\n            return Color.red + Color.blue;\n        }\n        else if (colorName == \"cyan\") {\n            return Color.green + Color.blue;\n        }\n    }\n}\n\n허용되지 않는 병합 (Disallowed Merges)\nTypeScript에서는 일부 병합이 허용되지 않습니다.현재 클래스는 다른 클래스 또는 변수와 병합할 수 없습니다.클래스 병합을 모방하는 방법에 대한 자세한 내용은 TypeScript의 Mixins 섹션을 참조하세요.\n모듈 확대 (Module Augmentation)\nJavaScript 모듈은 병합을 지원하지 않지만 기존 객체를 가져와서 업데이트할 수 있습니다.Observable 예제를 살펴봅시다:\n// observable.js\nexport class Observable {\n    // ... 구현은 숙제로 남겨놨습니다 ...\n}\n\n// map.js\nimport { Observable } from \"./observable\";\nObservable.prototype.map = function (f) {\n    // ... 또 다른 숙제\n}\n\n이것은 TypeScript에서도 잘 작동하지만 컴파일러는 Observable.prototype.map에 대해 알지 못합니다.이런 경우 모듈 확대를 사용하여 컴파일러에 다음에 대해 알릴 수 있습니다:\n// observable.ts는 그대로 유지됩니다.\n// map.ts\nimport { Observable } from \"./observable\";\ndeclare module \"./observable\" {\n    interface Observable {\n        map(f: (x: T) => U): Observable;\n    }\n}\nObservable.prototype.map = function (f) {\n    // ... 또 다른 숙제\n}\n\n\n// consumer.ts\nimport { Observable } from \"./observable\";\nimport \"./map\";\nlet o: Observable;\no.map(x => x.toFixed());\n\n모듈 이름은 import/export의 모듈 지정자와 같은 방법으로 해석됩니다.자세한 내용은 모듈을 참조하세요.확대되는 선언은 마치 원본과 같은 파일에 선언된 것처럼 병합됩니다.그러나 확대에서 새로운 최상위 레벨 선언을 새롭게 할 수는 없습니다. -- 기존 선언에 패치 만하면 됩니다.\n전역 확대 (Global augmentation)\n모듈 내부에서 전역 스코프 선언을 추가할 수도 있습니다.\n// observable.ts\nexport class Observable {\n    // ... 여전히 구현되지 않고 있습니다 ...\n}\n\ndeclare global {\n    interface Array {\n        toObservable(): Observable;\n    }\n}\n\nArray.prototype.toObservable = function () {\n    // ...\n}\n\n전역 확대는 모듈 확대와 같은 작동 및 제한 사항을 가집니다.\n"},"pages/JSX.html":{"url":"pages/JSX.html","title":"JSX","keywords":"","body":"소개\nJSX는 XML 같은 구문이  포함 가능합니다.의미는 구현에 따라 다르지만 유효한 JavaScript로 변형되어야 합니다.JSX는 React에서 인기를 얻었으나 이후 다른 애플리케이션도 볼 수 있습니다.TypeScript는 JSX를 직접 JavaScript에 포함, 타입 검사 및 컴파일할 수 있도록 지원합니다.\n기본 사용 방법\nJSX를 사용하려면 두 가지 작업을 해야 합니다.\n\n파일의 이름을 .tsx 확장자로 지정하세요\njsx 옵션을 활성화하세요\n\nTypeScript에는 세 가지 JSX 모드가 있습니다: preserve, react, 그리고 react-native.이 모드는 방출 단계에만 영향을 미칩니다 - 타입 검사에는 영향받지 않습니다.preserve 모드는 다른 변환 단계 (예: Babel)에서 더 사용되도록 출력의 일부로 JSX를 계속 유지합니다.추가적으로 출력에는 .jsx 파일 확장자가 지정되어 있습니다.react 모드는 React.createElement를 방출하고 사용하기 전에 JSX 변환을 거칠 필요가 없으며 출력은 .js 파일 확장자를 갖습니다.react-native 모드는 모든 JSX를 유지하고 있다는 점에서 preserve와 같지만 대신 출력은 .js 파일 확장자를 갖습니다.\n\n\n\n모드\n입력\n출력\n출력 파일 확장자\n\n\n\n\npreserve\n\n\n.jsx\n\n\nreact\n\nReact.createElement(\"div\")\n.js\n\n\nreact-native\n\n\n.js\n\n\n\n이 모드는 커맨드 라인의 --jsx 명령 또는 tsconfig.json 파일의 해당 옵션을 사용하여 지정할 수 있습니다.\n\n주의사항: React 식별자는 하드 코딩되어 있으므로 대문자 R.로 React를 사용할 수 있도록 해야 합니다.\n\nas 연산자 (The as operator)\n타입 단언 작성 방법을 회상해봅시다.\nvar foo = bar;\n\n여기서 변수 bar의 타입을 foo라고 주장하고 있습니다.TypeScript도 타입 단언을 위해 꺾쇠 괄호를 사용하기 때문에 JSX의 특정 구문 파싱에는 몇가지 어려움이 있습니다.결과적으로 TypeScript는 .tsx 파일에 꺾쇠 괄호 타입 단언을 허용하지 않습니다.\n이러한 .tsx 파일의 기능 손실을 채우기 위해 새로운 타입의 단언 연산자가  추가되었습니다: as.위 예제는 쉽게 as 연산자로 다시 작성할 수 있습니다.\nvar foo = bar as foo;\n\nas 연산자는 .ts와 .tsx 파일 모두에서 사용할 수 있으며 다른 타입 단언 스타일과 똑같이 동작합니다.\n타입 검사 (Type Checking)\nJSX 타입 검사를 이해하기 위해서는 먼저 내장 요소와 값-기반 요소 사이의 차이를 이해해야 합니다.JSX 표현식 이 주어지면 expr은 원래 환경에 내장된 것을 참조할 수 있습니다 (예: DOM 환경의 div 또는 span) 또는 직접 작성한 사용자 정의 구성 요소를 참조할 수 있습니다.\n이것이 중요한 두 가지 이유가 있습니다:\n\nReact의 경우, 내장 요소는 문자열 (React.createElement(\"div\"))로 방출되는 반면 생성한 컴포넌트는 (React.createElement(MyComponent))가 아닙니다.\nJSX 요소에서 전달되는 속성의 타입은 다르게 보여야합니다.내장 요소 속성은 본질적으로 알려져야 하는 반면에 컴포넌트는 자체 속성 집합을 지정하기를 원할 수 있습니다.\n\nTypeScript는 이러한 것들을 구분하기 위해 React와 같은 컨벤션을 사용합니다.내장 요소는 항상 소문자로 시작하고 값-기반 요소는 항상 대문자로 시작합니다.\n내장 요소 (Intrinsic elements)\n내장 요소는 JSX.IntrinsicElements라는 특수한 인터페이스에서 볼 수 있습니다.\n기본적으로 이 인터페이스가 지정되지 않으면 모든 내장 요소에 타입 검사는 하지 않습니다.다만 이 인터페이스가 존재하는 경우, 내부 요소의 이름은 JSX.IntrinsicElements 인터페이스의 프로퍼티로서 참조됩니다.\n예를 들어:\ndeclare namespace JSX {\n    interface IntrinsicElements {\n        foo: any\n    }\n}\n\n; // 좋아요\n; // 오류\n\n위의 예제에서 는 잘 동작하지만 는JSX.IntrinsicElements에 지정되지 않았기 때문에 오류가 발생합니다.\n\n참고: JSX.IntrinsicElements에서 다음과 같이 catch-all 문자열 indexer를 지정할 수도 있습니다:\ndeclare namespace JSX {\n   interface IntrinsicElements {\n       [elemName: string]: any;\n   }\n}\n\n\n값-기반 요소 (Value-based elements)\n값 기반 요소는 스코프에 있는 식별자로 간단히 조회됩니다.\nimport MyComponent from \"./myComponent\";\n\n; // 좋아요\n; // 오류\n\n값 기반 요소를 정의하는 방법에는 두 가지가 있습니다:\n\n무상태 함수형 컴포넌트 (SFC)\n클래스 컴포넌트\n\n이 두 가지 타입의 값 기반 요소는 JSX 표현식에서 구분할 수 없기 때문에 일단 오버로드 해석을 사용하여 무상태 함수형 컴포넌트로 표현식을 해결하려고 합니다.프로세스가 성공하면 선언에 대한 표현식을 해결합니다.만약 SFC로 해결하지 못한다면 클래스 컴포넌트로 해결합니다.만약 실패한다면 오류를 보고합니다.\n무상태 함수형 컴포넌트(Stateless Functional Component)\n이름에서 알 수 있듯이 컴포넌트는 첫 번째 인수가 props 객체인 JavaScript 함수로 정의됩니다.반환 타입은 JSX.Element에 할당할 수 있도록 강제합니다.\ninterface FooProp {\n  name: string;\n  X: number;\n  Y: number;\n}\n\ndeclare function AnotherComponent(prop: {name: string});\nfunction ComponentFoo(prop: FooProp) {\n  return ;\n}\n\nconst Button = (prop: {value: string}, context: { color: string }) => \n\nSFC는 단순히 JavaScript 함수이기 때문에 여기서도 함수 오버로드를 활용할 수 있습니다.\ninterface ClickableProps {\n  children: JSX.Element[] | JSX.Element\n}\n\ninterface HomeProps extends ClickableProps {\n  home: JSX.Element;\n}\n\ninterface SideProps extends ClickableProps {\n  side: JSX.Element | string;\n}\n\nfunction MainButton(prop: HomeProps): JSX.Element;\nfunction MainButton(prop: SideProps): JSX.Element {\n  ...\n}\n\n클래스 컴포넌트 (Class Component)\n클래스 컴포넌트의 타입을 제한할 수 있습니다.하지만 이를 위해 새로운 두 가지를 도입해야 합니다: 요소 클래스 타입과 요소 인스턴스 타입\n에 주어진 요소 클래스 타입은 Expr입니다.따라서 위 예제의 MyComponent가 ES6 클래스라면 이 클래스가 그 클래스 타입이 될 것입니다.만일 MyComponent가 팩토리 함수라면 클래스 타입이 그 함수가 될 것입니다.\n한 번 클래스 타입이 설정되면 인스턴스 타입은 클래스 타입의 호출 시그니처과 구조 시그니처의 반환 타입 유니온에 따라 결정됩니다.다시 ES6 클래스의 경우, 인스턴스 타입은 해당 클래스의 인스턴스 타입이 되고 팩토리 함수의 경우 해당 함수에서 반환되는 값의 타입이 됩니다.\nclass MyComponent {\n  render() {}\n}\n\n// 구조 시그니처 사용\nvar myComponent = new MyComponent();\n\n// 요소 클래스 타입 => MyComponent\n// 요소 인스턴스 타입 => { render: () => void }\n\nfunction MyFactoryFunction() {\n  return {\n    render: () => {\n    }\n  }\n}\n\n// 호출 시그니처 사용\nvar myComponent = MyFactoryFunction();\n\n// 요소 클래스 타입 => 팩토리 함수\n// 요소 인스턴스 타입 => { render: () => void }\n\n요소 인스턴스 타입이 흥미로운 이유는 JSX.ElementClass에 할당되어야 하며 그렇지 않을 경우 오류가 발생하기 때문입니다.기본적으로 JSX.ElementClass는 {}이지만 JSX의 사용을 적절한 인터페이스에 맞는 타입으로 제한하도록 확장할 수 있습니다.\ndeclare namespace JSX {\n  interface ElementClass {\n    render: any;\n  }\n}\n\nclass MyComponent {\n  render() {}\n}\nfunction MyFactoryFunction() {\n  return { render: () => {} }\n}\n\n; // 좋아요\n; // 좋아요\n\nclass NotAValidComponent {}\nfunction NotAValidFactoryFunction() {\n  return {};\n}\n\n; // 오류\n; // 오류\n\n속성 타입 검사 (Attribute type checking)\n속성 타입 검사를 하는 첫 번째 단계는 요소 속성 타입을 결정하는 것입니다.이것은 내장 요소와 값 기반 요소 간에 약간의 차이가 있습니다.\n내장 요소의 경우 JSX.IntrinsicElements 프로퍼티의 타입입니다.\ndeclare namespace JSX {\n  interface IntrinsicElements {\n    foo: { bar?: boolean }\n  }\n}\n\n// 'foo'에 대한 요소 속성 타입은 '{bar?: boolean}'입니다.\n;\n\n값 기반 요소의 경우 조금 더 복잡합니다.이전에 결정된 요소 인스턴스 타입의 프로퍼티 타입에 따라 결정됩니다.사용할 프로퍼티는 JSX.ElementAttributesProperty에 의해 결정됩니다.단일 프로퍼티로 선언해야 합니다.그런 다음 해당 프로퍼티의 이름이 사용됩니다.\ndeclare namespace JSX {\n  interface ElementAttributesProperty {\n    props; // 사용할 프로퍼티 이름을 지정합니다\n  }\n}\n\nclass MyComponent {\n  // 요소 인스턴스 타입에 대한 프로퍼티를 지정합니다\n  props: {\n    foo?: string;\n  }\n}\n\n// 'MyComponent'의 요소 속성 타입은 '{foo?: string}'입니다\n\n\n요소 속성 타입은 JSX에서 속성을 타입을 확인하는 데 사용됩니다.선택적 프로퍼티와 필수 프로퍼티가 지원됩니다.\ndeclare namespace JSX {\n  interface IntrinsicElements {\n    foo: { requiredProp: string; optionalProp?: number }\n  }\n}\n\n; // 좋아요\n; // 좋아요\n; // 오류, requiredProp이 없습니다\n; // 오류, requiredProp이 문자열이어야 합니다.\n; // 오류, unknownProp이 존재하지 않습니다.\n; // 좋아요, 'some-unknown-prop' 은 유효한 식별자가 아니기 때문입니다.\n\n\n참고: 속성 이름이 유효한 JS 식별자 (예 :data- *속성)가 아닌 경우 요소 속성 타입에서 속성 이름을 찾을 수 없으면 오류로 간주되지 않습니다.\n\n전개 연산자도 작동합니다:\nvar props = { requiredProp: \"bar\" };\n; // 좋아요\n\nvar badProps = {};\n; // 오류\n\n하위 타입 검사 (Children Type Checking)\n2.3 버전에서 하위 타입 검사를 도입했습니다.하위(children)는 요소 타입 검사에서 결정된 요소 속성 타입의 프로퍼티 입니다.JSX.ElementAttributesProperty를 사용하여 props 이름을 결정하는 것과 마찬가지로 JSX.ElementChildrenAttribute를 사용하여 하위 이름을 결정합니다.JSX.ElementChildrenAttribute는 단일 프로퍼티로 선언해야합니다.\ndeclare namespace JSX {\n  interface ElementChildrenAttribute {\n    children: {};  // 사용할 하위 이름을 지정하세요\n  }\n}\n\n하위의 타입을 명시적으로 지정하지 않는다면 React typings의 기본 타입을 사용합니다.\n\n  Hello\n;\n\n\n  Hello\n  World\n;\n\nconst CustomComp = (props) => props.children\n\n  Hello World\n  {\"This is just a JS expression...\" + 1000}\n\n\n다른 속성과 마찬가지로 하위 타입을 지정할 수 있습니다.이렇게 하면 React typings에서 기본 타입을 덮어쓰게 됩니다.\ninterface PropsType {\n  children: JSX.Element\n  name: string\n}\n\nclass Component extends React.Component {\n  render() {\n    return (\n      \n        this.props.children\n      \n    )\n  }\n}\n\n// 좋아요\n\n  Hello World\n\n\n// 오류: 하위 타입은 JSX.Element의 배열이 아닌 JSX.Element 타입입니다.\n\n  Hello World\n  Hello World\n\n\n// 오류: 하위 타입은 JSX.Element 또는 string의 배열이 아닌 JSX.Element 타입입니다.\n\n  Hello\n  World\n\n\nJSX 결과 타입 (The JSX result type)\n기본적으로 JSX 표현식의 결과 타입은 any로 분류됩니다.JSX.Element 인터페이스를 지정하여 사용자 정의 타입을 사용할 수 있습니다.그러나 이 인터페이스에서 JSX의 요소, 속성 또는 하위 항목에 대한 타입 정보를 찾을 수 없습니다.이것은 블랙박스 입니다.\n표현식 포함하기 (Embedding Expressions)\nJSX는 중괄호 ({ })로 표현식을 감싸고 태그 사이에 표현식을 삽입할 수 있게합니다.\nvar a = \n  {[\"foo\", \"bar\"].map(i => {i / 2})}\n\n\n위의 코드는 문자열을 숫자로 나눌 수 없으므로 오류가 발생합니다.\n출력은 preserve 옵션을 사용할 때 다음과 같습니다:\nvar a = \n  {[\"foo\", \"bar\"].map(function (i) { return {i / 2}; })}\n\n\n리액트 통합 (React integration)\nReact와 함께 JSX를 사용하려면 React typings을 사용해야 합니다.이러한 typings은 React와 함께 사용하기에 적합하도록 JSX 네임스페이스를 적절하게 정의합니다.\n/// \n\ninterface Props {\n  foo: string;\n}\n\nclass MyComponent extends React.Component {\n  render() {\n    return {this.props.foo}\n  }\n}\n\n; // 좋아요\n; // 오류\n\n"},"pages/Decorators.html":{"url":"pages/Decorators.html","title":"데코레이터","keywords":"","body":"소개\nTypeScript와 ES6의 클래스가 도입됨에 따라 클래스 및 클래스 멤버에 어노테이션 또는 변경을 지원하기 위해 추가적인 기능이 필요한 일부 상황이 있습니다.데코레이터는 클래스 선언과 멤버에 대한 어노테이션과 메타-프로그래밍 구문을 모두 추가할 수 있는 방법을 제공합니다.데코레이터는 JavaScript의 stage 2 제안이며 TypeScript의 실험적인 기능으로 사용할 수 있습니다.\n\n주의사항  데코레이터는 향후 변경될 수 있는 실험적 기능입니다.\n\n데코레이터에 대한 실험적인 지원을 사용하려면 커맨드 라인이나 tsconfig.json에서 experimentalDecorators 컴파일러 옵션을 사용하도록 활성화해야 합니다:\n커맨드 라인:\ntsc --target ES5 --experimentalDecorators\n\ntsconfig.json:\n{\n    \"compilerOptions\": {\n        \"target\": \"ES5\",\n        \"experimentalDecorators\": true\n    }\n}\n\n데코레이터\n데코레이터는 클래스 선언, 메서드, 접근제어자, 프로퍼티 또는 매개변수에 첨부될 수 있는 특별한 종류의 선언입니다.데코레이터는 @표현식의 형태를 사용하는데, 여기서 표현식은 데코레이팅된 선언에 대한 정보와 함께 런타임에 호출될 함수로 평가되어야 합니다.  \n예를 들어, 데코레이터 @sealed을 사용하여 다음과 같이 sealed 함수를 작성할 수 있습니다:\nfunction sealed(target) {\n    // 'target'으로 뭐든 해보세요 ...\n}\n\n\n주의사항  아래의 클래스 데코레이터에서 데코레이터에 대한 더욱 자세한 예제를 볼 수 있습니다.\n\n데코레이터 팩토리\n선언에 데코레이터를 적용하는 방법을 커스터마이징하고 싶다면 데코레이터 팩토리를 작성할 수 있습니다.Decorator Factory는 간단히 런타임에 데코레이터에 의해 호출될 표현식을 반환하는 함수입니다.\n다음과 같은 방식으로 데코레이터 팩토리를 작성할 수 있습니다:\nfunction color(value: string) { // 이것은 데코레이터 팩토리입니다\n    return function (target) { // 이것은 데코레이터입니다\n        // 'target'과 'value'로 뭐든 해보세요...\n    }\n}\n\n\n주의사항  아래의 메서드 데코레이터에서 데코레이터 팩토리에 대한 더욱 자세한 예제를 볼 수 있습니다.\n\n데코레이터 구성\n다음 예제처럼 여러 데코레이터를 선언에 적용 할 수 있습니다:\n\n한 줄에:\n@f @g x\n\n\n여러 줄에:\n@f\n@g\nx\n\n\n\n여러 데코레이터가 단일 선언에 적용되는 경우 평가는 수학에서의 함수 구성과 유사합니다.이 모델에서 함수 f와 g을 구성할 때, 결과적인 합성 (f ∘ g)(x)은(는) f(g(x))와 동일합니다.\n따라서 TypeScript의 단일 선언에서 여러 데코레이터를 평가할 때 다음 단계를 수행합니다:\n\n각 데코레이터에 대한 표현식은 위에서 아래로 평가됩니다.\n그런 다음 결과는 아래에서 위로 함수를 호출합니다.\n\n데코레이터 팩토리를 사용하려면 다음 예제에서 이 평가 순서를 관찰할 수 있습니다:\nfunction f() {\n    console.log(\"f(): evaluated\");\n    return function (target, propertyKey: string, descriptor: PropertyDescriptor) {\n        console.log(\"f(): called\");\n    }\n}\n\nfunction g() {\n    console.log(\"g(): evaluated\");\n    return function (target, propertyKey: string, descriptor: PropertyDescriptor) {\n        console.log(\"g(): called\");\n    }\n}\n\nclass C {\n    @f()\n    @g()\n    method() {}\n}\n\n그러면 이 출력을 콘솔에 출력합니다:\nf(): evaluated\ng(): evaluated\ng(): called\nf(): called\n\n데코레이터 평가 (Decorator Evaluation)\n클래스 내의 다양한 선언에 데코레이터를 적용하는 방법에는 잘 정의된 순서가 있습니다:\n매개 변수 Decorator, 메서드, 접근제어자 또는 속성 Decorator가 각 정적 멤버에 적용됩니다.\nMethod, Accessor, PropertiesDecorator등에 의한 파라미터 Decorator는 각 정적 멤버에 대해 적용된다.\n\n메서드, 접근제어자 또는 프로퍼티 데코레이터에 이어지는 매개변수 데코레이터는 각 인스턴스 멤버에 적용됩니다.\n메서드, 접근제어자 또는 프로퍼티 데코레이터에 이어지는 매개변수 데코레이터는 각 정적 멤버에 적용됩니다.\n매개변수 데코레이터는 생성자에 적용됩니다.\n클래스 데코레이터는 클래스에 적용됩니다.\n\n클래스 데코레이터 (Class Decorators)\n클래스 데코레이터는 클래스 선언 바로 직전에 선언됩니다.클래스 데코레이터는 클래스 정의를 관찰, 수정 또는 바꾸는 데 사용할 수 있는 클래스 생성자에 적용됩니다.클래스 데코레이터는 선언 파일이나 다른 ambient 컨텍스트(예: 선언 클래스)에서 사용할 수 없습니다.\n클래스 데코레이터에 대한 표현식은 런타임에 함수로 호출되며 데코레이팅 클래스의 생성자는 대상을 유일한 인수로 호출됩니다.\n클래스 데코레이터가 값을 반환하는 경우, 클래스 선언을 제공된 생성자 함수로 대체합니다.\n\n주의사항  새 생성자 함수를 반환하도록 선택해야하는 경우 원본 프로토타입을 유지하도록 관리해야합니다. 런타임에 데코레이터를 적용하는 로직은 이 작업을 수행하지 않습니다.\n\n다음은 Greeter 클래스에 적용된 클래스 데코레이터(@sealed)의 예제입니다:\n@sealed\nclass Greeter {\n    greeting: string;\n    constructor(message: string) {\n        this.greeting = message;\n    }\n    greet() {\n        return \"Hello, \" + this.greeting;\n    }\n}\n\n다음 함수 선언을 사용하여 @sealed 데코레이터를 정의할 수 있습니다:\nfunction sealed(constructor: Function) {\n    Object.seal(constructor);\n    Object.seal(constructor.prototype);\n}\n\n@sealed가 실행되면 생성자와 프로토타입 모두를 봉인합니다.다음은 생성자를 재정의하는 방법에 대한 예제입니다.\nfunction classDecorator(constructor:T) {\n    return class extends constructor {\n        newProperty = \"new property\";\n        hello = \"override\";\n    }\n}\n\n@classDecorator\nclass Greeter {\n    property = \"property\";\n    hello: string;\n    constructor(m: string) {\n        this.hello = m;\n    }\n}\n\nconsole.log(new Greeter(\"world\"));\n\n메서드 데코레이터 (Method Decorators)\n메서드 데코레이터는 메서드 선언 바로 직전에 선언됩니다.데코레이터는 메서드의 프로퍼티 Descriptor에 적용되며 메서드 정의를 관찰, 수정 또는 바꾸는 데 사용할 수 있습니다.메서드 데코레이터는 선언 파일, 오버로드 또는 기타 ambient 컨텍스트 (예: 선언 클래스)에서 사용할 수 없습니다.\n메서드 데코레이터의 표현식은 런타임에 다음 세 가지 인수와 함께 함수로 호출됩니다:\n\n정적 멤버에 대한 클래스의 생성자 함수거나 인스턴스 멤버에 대한 클래스의 프로토타입\n멤버의 이름\n멤버의 프로퍼티 Descriptor\n\n\n주의사항  스크립트 타겟이 ES5보다 작은 경우 프로퍼티 Descriptor는 undefined가 됩니다.\n\n메서드 데코레이터가 값을 반환하는 경우 해당 메서드에 대해 프로퍼티 Descriptor로 사용됩니다.\n\n주의사항  스크립트 타겟이 ES5보다 작은 경우 반환 값은 무시됩니다.\n\n다음은 Greeter클래스의 메서드에 적용된 메서드 데코레이터 (@enumerable)의 예제입니다:\nclass Greeter {\n    greeting: string;\n    constructor(message: string) {\n        this.greeting = message;\n    }\n\n    @enumerable(false)\n    greet() {\n        return \"Hello, \" + this.greeting;\n    }\n}\n\n다음 함수 선언을 사용하여 @enumerable 데코레이터를 정의할 수 있습니다:\nfunction enumerable(value: boolean) {\n    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {\n        descriptor.enumerable = value;\n    };\n}\n\n@enumerable(false) 데코레이터는 데코레이터 팩토리입니다.@enumerable(false) 데코레이터가 호출되면 프로퍼티 Descriptor의 enumerable 프로퍼티를 수정합니다.\n접근제어자 데코레이터 (Accessor Decorators)\n접근제어자 데코레이터는 접근제어자 선언 바로 직전에 선언됩니다.접근제어자 데코레이터는 접근제어자에 대한 프로퍼티 Descriptor에 적용되며 접근제어자 정의를 관찰, 수정 또는 바꾸는 데 사용할 수 있습니다.데코레이터는 메서드의 프로퍼티 Descriptor에 적용되며 메서드 정의를 관찰, 수정 또는 바꾸는 데 사용할 수 있습니다.접근제어자 데코레이터는 선언 파일이나 다른 ambient 컨텍스트 (예: 선언 클래스)에서 사용할 수 없습니다.\n\n주의사항  TypeScript는 단일 멤버에 대한 접근제어자 get과 set 모두 데코레이팅하는 것을 허용하지 않습니다.\n대신 멤버의 모든 데코레이터가 순서를 따라 첫 번째 접근제어자에게 적용되어야 합니다. 왜냐하면 데코레이터가 프로퍼티 Descriptor에 적용되기 때문입니다. 그리고 각 선언을 별도로 구분하지 않고 get과 set 접근제어자를 결합합니다.\n\n접근제어자 데코레이터 표현식은 런타임시 다음 세 가지 인수와 함께 함수로 호출됩니다:\n\n정적 멤버에 대한 클래스의 생성자 함수나 인스턴스 멤버에 대한 클래스의 프로토타입이 있습니다\n멤버의 이름\n멤버에 프로퍼티 Descriptor\n\n\n주의사항  스크립트 타겟이 ES5보다 작은 경우 프로퍼티 Descriptor는 undefined가 됩니다.\n\n접근제어자 데코레이터가 값을 반환하면 경우 해당 멤버에 대한 프로퍼티 Descriptor로 사용됩니다.\n\n주의사항  스크립트 타겟이 ES5보다 작은 경우 반환 값은 무시됩니다.\n\n다음은 Point 클래스의 멤버에 적용된 접근제어자 데코레이터 (@configurable)의 예제입니다:\nclass Point {\n    private _x: number;\n    private _y: number;\n    constructor(x: number, y: number) {\n        this._x = x;\n        this._y = y;\n    }\n\n    @configurable(false)\n    get x() { return this._x; }\n\n    @configurable(false)\n    get y() { return this._y; }\n}\n\n다음 함수 선언을 사용하여 @configurable 데코레이터를 정의할 수 있습니다:\nfunction configurable(value: boolean) {\n    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {\n        descriptor.configurable = value;\n    };\n}\n\n프로퍼티 데코레이터 (Property Decorators)\n프로퍼티 데코레이터는 프로퍼티 선언 바로 직전에 선언됩니다.프로퍼티 데코레이터는 선언 파일이나 기타 ambient 컨텍스트 (예: 선언 클래스)에서 사용할 수 없습니다.\n프로퍼티 데코레이터의 표현식은 런타임에 다음 두 가지 인수와 함께 함수로 호출됩니다:\n\n정적 멤버에 대한 클래스의 생성자 함수 또는 인스턴스 멤버에 대한 클래스의 프로토타입\n멤버의 이름\n\n\n주의사항  프로퍼티 Descriptor는 프로퍼티 Descriptor가 TypeScript에서 초기화되는 방법으로 인해 프로퍼티 Descriptor에 대한 인수로 제공되지 않습니다.\n이는 현재 프로토타입의 멤버을 정의할 때 인스턴스 프로퍼티를 설명하는 메커니즘이 없고, 프로퍼티에 대한 이니셜라이저를 관찰하거나 수정할 방법이 없기 때문이다. 반환 값도 무시됩니다.\n따라서 프로퍼티 데코레이터는 특정 이름의 프로퍼티가 클래스에 대해 선언되는 것을 관찰하는 데만 사용할 수 있습니다.\n\n다음 예와 같이 이 정보를 사용하여 프로퍼티에 대한 메타 데이터를 기록할 수 있습니다:\nclass Greeter {\n    @format(\"Hello, %s\")\n    greeting: string;\n\n    constructor(message: string) {\n        this.greeting = message;\n    }\n    greet() {\n        let formatString = getFormat(this, \"greeting\");\n        return formatString.replace(\"%s\", this.greeting);\n    }\n}\n\n그 다음 함수 선언을 사용하여 @format 데코레이터와 getFormat 함수를 정의 할 수 있습니다:\nimport \"reflect-metadata\";\n\nconst formatMetadataKey = Symbol(\"format\");\n\nfunction format(formatString: string) {\n    return Reflect.metadata(formatMetadataKey, formatString);\n}\n\nfunction getFormat(target: any, propertyKey: string) {\n    return Reflect.getMetadata(formatMetadataKey, target, propertyKey);\n}\n\n@format(\"Hello, %s\") 데코레이터는 데코레이터 팩토리입니다.@format(\"Hello, %s\")이 호출되면 reflect-metadata 라이브러리의 Reflect.metadata 함수를 사용하여 프로퍼티에 대한 메타 데이터 항목을 추가합니다.getFormat를 호출하면 포맷에 대한 메타 데이터를 읽습니다.\n\n참고  이 예제에는 reflect-metadata 라이브러리가 필요합니다. reflect-metadata 라이브러리에 대한 자세한 정보는 메타 데이터를 참조하세요.\n\n매개변수 데코레이터 (Parameter Decorators)\n매개변수 데코레이터는 매개변수 선언 바로 직전에 선언됩니다.매개변수 데코레이터는 클래스 생성자 또는 메서드 선언의 함수에 적용됩니다.매개변수 데코레이터는 선언 파일, 오버로드 또는 기타 ambient 컨텍스트 (예: 선언 클래스)에서 사용할 수 없습니다.\n매개변수 데코레이터의 표현식은 런타임에 다음 세 가지 인수와 함께 함수로 호출됩니다:\n\n정적 멤버에 대한 클래스의 생성자 함수 또는 인스턴스 멤버에 대한 클래스의 프로토타입\n멤버의 이름\n함수의 매개 변수 목록내에 매개 변수의 서수(순서가 있는) 인덱스\n\n\n주의사항  매개변수 데코레이터는 매개변수가 메서드에 선언되었음을 관찰하는 데만 사용할 수 있습니다.\n\n매개변수 데코레이터의 반환 값은 무시됩니다.\n다음은 Greeter 클래스 멤버의 매개 변수에 적용된 매개 변수 데코레이터 (@required)의 예제입니다:\nclass Greeter {\n    greeting: string;\n\n    constructor(message: string) {\n        this.greeting = message;\n    }\n\n    @validate\n    greet(@required name: string) {\n        return \"Hello \" + name + \", \" + this.greeting;\n    }\n}\n\n그 다음 함수 선언을 사용해 @required와 @validate 데코레이터를 정의할 수 있습니다:\nimport \"reflect-metadata\";\n\nconst requiredMetadataKey = Symbol(\"required\");\n\nfunction required(target: Object, propertyKey: string | symbol, parameterIndex: number) {\n    let existingRequiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyKey) || [];\n    existingRequiredParameters.push(parameterIndex);\n    Reflect.defineMetadata(requiredMetadataKey, existingRequiredParameters, target, propertyKey);\n}\n\nfunction validate(target: any, propertyName: string, descriptor: TypedPropertyDescriptor) {\n    let method = descriptor.value;\n    descriptor.value = function () {\n        let requiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyName);\n        if (requiredParameters) {\n            for (let parameterIndex of requiredParameters) {\n                if (parameterIndex >= arguments.length || arguments[parameterIndex] === undefined) {\n                    throw new Error(\"Missing required argument.\");\n                }\n            }\n        }\n\n        return method.apply(this, arguments);\n    }\n}\n\n@required 데코레이터는 필요에 따라 매개변수를 표시하는 메타 데이터 항목을 추가합니다.@validate 데코레이터는 기존 메서드을 호출하기 전에 기존의 greet 메서드를  validates 함수로 래핑합니다.\n\n주의사항  이 예제에는 reflect-metadata 라이브러리가 필요합니다. reflect-metadata 라이브러리에 대한 자세한 정보는 메타 데이터를 참조하세요.\n\n메타 데이터\n일부 예제에서는 실험적인 메타 데이터 API에 대한 polyfill을 추가하는 reflect-metadata 라이브러리를 사용합니다.이 라이브러리는 아직 ECMAScript (JavaScript) 표준에 속하지 않습니다.하지만 데코레이터가 공식적으로 ECMAScript 표준의 일부로 채택되면 이러한 확장 기능이 채택되도록 제안될 것입니다.\n이 라이브러리는 npm을 통해 설치할 수 있습니다:\nnpm i reflect-metadata --save\n\nTypeScript는 데코레이터가 있는 선언에 대한 특정 타입의 메타 데이터를 방출하기 위한 실험적인 지원을 포함하고 있습니다.이 실험적인 지원을 활성화하려면 커맨드 라인 또는 tsconfig.json에서  컴파일러 옵션 emitDecoratorMetadata을 설정해야 합니다:\n커맨드 라인:\ntsc --target ES5 --experimentalDecorators --emitDecoratorMetadata\n\ntsconfig.json:\n{\n    \"compilerOptions\": {\n        \"target\": \"ES5\",\n        \"experimentalDecorators\": true,\n        \"emitDecoratorMetadata\": true\n    }\n}\n\n활성화가 될 때 reflect-metadata 라이브러리를 임포트 한 추가적인 design-time 타입 정보는 런타임에 노출됩니다.\n다음 예제에서는 이러한 기능이 실제로 작동하는 것을 볼 수 있습니다:\nimport \"reflect-metadata\";\n\nclass Point {\n    x: number;\n    y: number;\n}\n\nclass Line {\n    private _p0: Point;\n    private _p1: Point;\n\n    @validate\n    set p0(value: Point) { this._p0 = value; }\n    get p0() { return this._p0; }\n\n    @validate\n    set p1(value: Point) { this._p1 = value; }\n    get p1() { return this._p1; }\n}\n\nfunction validate(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) {\n    let set = descriptor.set;\n    descriptor.set = function (value: T) {\n        let type = Reflect.getMetadata(\"design:type\", target, propertyKey);\n        if (!(value instanceof type)) {\n            throw new TypeError(\"Invalid type.\");\n        }\n        set(value);\n    }\n}\n\nTypeScript 컴파일러는 @Reflect.metadata 데코레이터를 사용하여 design-time 타입 정보를 주입합니다.\n다음과 같은 TypeScript와 동일한 것으로 간주할 수 있습니다:\nclass Line {\n    private _p0: Point;\n    private _p1: Point;\n\n    @validate\n    @Reflect.metadata(\"design:type\", Point)\n    set p0(value: Point) { this._p0 = value; }\n    get p0() { return this._p0; }\n\n    @validate\n    @Reflect.metadata(\"design:type\", Point)\n    set p1(value: Point) { this._p1 = value; }\n    get p1() { return this._p1; }\n}\n\n\n참고  데코레이터 메타 데이터는 시험적인 기능이며 향후 공개에서 중요한 변경 사항을 도입할 수 있습니다.\n\n"},"pages/Mixins.html":{"url":"pages/Mixins.html","title":"믹스인","keywords":"","body":"소개\n전통적인 OO 계층 구조와 함께 재사용 가능한 컴포넌트로 클래스를 구축하는 또 다른 보편적인 방법은 더 간단한 부분의 클래스를 결합하여 클래스를 구축하는 것입니다.여러분은 스칼라와 같은 언어에서의 믹스인이나 특성에 대한 사상에 익숙할 수 있으며 이 패턴은 JavaScript 커뮤니티에서도 인기를 얻고 있습니다.\n믹스인 샘플\n아래 코드에서는 TypeScript에서 믹스인을 모델링하는 방법을 보여줍니다.코드가 끝나면 어떻게 작동하는지 분석해보겠습니다.\n// Disposable 믹스인\nclass Disposable {\n    isDisposed: boolean;\n    dispose() {\n        this.isDisposed = true;\n    }\n\n}\n\n// Activatable 믹스인\nclass Activatable {\n    isActive: boolean;\n    activate() {\n        this.isActive = true;\n    }\n    deactivate() {\n        this.isActive = false;\n    }\n}\n\nclass SmartObject implements Disposable, Activatable {\n    constructor() {\n        setInterval(() => console.log(this.isActive + \" : \" + this.isDisposed), 500);\n    }\n\n    interact() {\n        this.activate();\n    }\n\n    // Disposable\n    isDisposed: boolean = false;\n    dispose: () => void;\n    // Activatable\n    isActive: boolean = false;\n    activate: () => void;\n    deactivate: () => void;\n}\napplyMixins(SmartObject, [Disposable, Activatable]);\n\nlet smartObj = new SmartObject();\nsetTimeout(() => smartObj.interact(), 1000);\n\n////////////////////////////////////////\n// 런타임 라이브러리 어딘가에\n////////////////////////////////////////\n\nfunction applyMixins(derivedCtor: any, baseCtors: any[]) {\n    baseCtors.forEach(baseCtor => {\n        Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {\n            derivedCtor.prototype[name] = baseCtor.prototype[name];\n        });\n    });\n}\n\n샘플 이해하기\n믹스인으로 작동할 코드 샘플은 두 클래스로 시작합니다.각각의 개체가 특정 활동이나 능력에 초점을 맞추고 있다는 것을 볼 수 있습니다.나중에는 이 두 가지를 결합하여 새로운 클래스를 만들겠습니다.\n// Disposable\nclass Disposable {\n    isDisposed: boolean;\n    dispose() {\n        this.isDisposed = true;\n    }\n\n}\n\n// Activatable\nclass Activatable {\n    isActive: boolean;\n    activate() {\n        this.isActive = true;\n    }\n    deactivate() {\n        this.isActive = false;\n    }\n}\n\n다음으로 두 믹스인의 결합을 처리할 클래스를 만들 것입니다.이 기능에 대해 자세히 살펴보겠습니다:\nclass SmartObject implements Disposable, Activatable {\n\n위에서 첫 번째로 주목할 점은 extends 대신 implements를 사용한다는 것입니다.이것은 클래스를 인터페이스로 다루고 구현이 아닌 Disposable과 Activatable 타입만 사용합니다.즉, 클래스에서 구현을 제공해야 합니다.이외에 정확하게는 믹스인 사용하여 회피하고 싶은 것입니다.\n이 요구 사항을 충족시키기 위해 믹스인에서 가져올 멤버에 대해 stand-in 프로퍼티과 그 타입을 생성합니다.이것은 컴파일러가 런타임에 이러한 멤버를 사용할 수 있음을 충족시킵니다.비록 약간의 bookkeeping 오버헤드가 있기는 하지만 여전히 믹스인의 이점을 얻을 수 있습니다.\n// Disposable\nisDisposed: boolean = false;\ndispose: () => void;\n// Activatable\nisActive: boolean = false;\nactivate: () => void;\ndeactivate: () => void;\n\n마지막으로, 믹스인을 클래스에 믹싱하여 완벽한 구현을 만들어냅니다.\napplyMixins(SmartObject, [Disposable, Activatable]);\n\n마지막으로 믹스인을 하기 위한 헬퍼 함수를 만듭니다.이것은 각 믹스인의 프로퍼티를 거쳐 실행되며 믹스인의 타겟으로 복사하고 구현된 stand-in 프로퍼티로 채우게 됩니다.\nfunction applyMixins(derivedCtor: any, baseCtors: any[]) {\n    baseCtors.forEach(baseCtor => {\n        Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {\n            derivedCtor.prototype[name] = baseCtor.prototype[name];\n        });\n    });\n}\n\n"},"pages/Triple-Slash Directives.html":{"url":"pages/Triple-Slash Directives.html","title":"트리플-슬래시 지시자","keywords":"","body":"트리플-슬래시 지시자는 단일 XML 태그가 포함된 한 줄 주석입니다.주석의 내용은 컴파일러 지시자로 사용됩니다.\n트리플-슬래시 지시자는 포함된 파일의 상단에서만 유효합니다.트리플-슬래시 지시자는 다른 트리플-슬래시 지시자를 포함하여 한 줄 또는 여러 줄 주석 앞에 붙을 수 있습니다.문 또는 선언 뒤에 나오는 경우 보통의 한 줄 주석으로 간주하며 특별한 의미는 없습니다.\n/// \n이 중 가장 일반적인 것은 ///  지시자입니다.파일 간에 의존성 선언의 역할을 합니다.\n트리플-슬래시 참조는 컴파일 프로세스에서 추가적인 파일을 포함하도록 컴파일러에 지시합니다.\n또한 --out 또는 --outFile을 사용할 때 출력을 정렬하는 방법으로도 사용됩니다.파일은 전처리 통과 후 입력과 같은 순서의 출력 파일 위치로 방출됩니다.\n전처리 입력 파일 (Preprocessing input files)\n컴파일러는 모든 트리플-슬래시 참조 지시자를 해석하기 위해 입력 파일에 대한 전처리 단계를 수행합니다.이러한 프로세스 중 컴파일에 추가 파일이 추가됩니다.\n프로세스는 root files 집합으로 시작합니다.이것은 커맨드 라인이나 tsconfig.json 파일의 \"files\" 리스트에 지정된 파일 이름입니다.이러한 루트 파일은 지정된 순서대로 전처리됩니다.파일이 목록에 추가되기 전에 파일에 있는 모든 트리플-슬래시 참조가 처리되고 대상이 포함됩니다.트리플-슬래시 참조는 파일에서 본 순서대로 우선으로 깊숙하게 분석됩니다.\n루트가 없는 경우 트리플-슬래시는 포함된 파일에 대한 기준으로 경로를 해석합니다.\n오류\n존재하지 않는 파일을 참조하는 것은 오류입니다.파일에 자체에 대한 트리플-슬래시 참조가 있는 것은 오류입니다.\n--noResolve 사용\n컴파일러 옵션 --noResolve가 지정되면 트리플-슬래시 참조는 무시됩니다.새 파일을 추가하거나 제공된 파일의 순서를 변경하지도 않습니다.\n/// \n///  지시자와 마찬가지로 이 지시자도 의존성 선언의 역할을 합니다.하지만 /// 지시자는 패키지에 대한 의존성을 선언합니다.\n이런 패키지 이름을 해석하는 프로세스는 import문에서 모듈 이름을 해석하는 프로세스와 유사합니다.트리플-슬래시 참조 타입 지시자를 생각하는 쉬운 방법은 선언 패키지의 import 입니다.\n예를 들어 선언 파일에 /// 를 포함하면 이 파일은 @types/node/index.d.ts에 선언된 이름을 사용합니다.따라서 선언 파일과 함께 이 패키지를 컴파일에 포함해야 합니다.\n이 지시자는 d.ts 파일을 직접 작성할 때만 사용하도록 하세요.\n컴파일 시 생성된 선언 파일에 대해서는 컴파일러가 /// 을 자동으로 추가합니다.생성된 선언 파일에서 /// 은 결과 파일이 참조 패키지의 선언을 사용하는 경우에만 추가됩니다.\n.ts 파일에 대한 @types 패키지에 의존성을 선언하려면 커맨드 라인이나 tsconfig.json에서 --types를 사용하세요.\n더 자세한 내용은 tsconfig.json 파일에서 @types, typeRoots와 types 사용하기를 보세요.\n/// \n이 지시자는 파일을 기본 라이브러리로 표시합니다.이 주석은 lib.d.ts와 다른 변이들의 맨 위에서 볼 수 있습니다.\n이 지시자는 컴파일러에 기본 라이브러리 (예: lib.d.ts)를 포함하지 않도록 지시합니다.여기에 미치는 영향은 커맨드 라인에 --noLib를 전달하는 것과 비슷합니다.\n또한 --skipDefaultLibCheck를 넘길 때 컴파일러는 /// 를 가진 파일 검사만 건너뜁니다.\n/// \n기본적으로 AMD모듈은 익명으로 생성됩니다.이로 인해 번들(예: r.js)과 같은 결과적인 모듈을 처리하는 데 다른 도구를 사용할 경우 문제가 발생할 수 있습니다.\namd-module 지시자는 선택적 모듈 이름을 컴파일러에 전달하는 것을 허용합니다:\namdModule.ts\n///\nexport class C {\n}\n\nAMD define을 호출할 때 NamedModule이라는 이름을 모듈에 할당할 것입니다:\namdModule.js\ndefine(\"NamedModule\", [\"require\", \"exports\"], function (require, exports) {\n    var C = (function () {\n        function C() {\n        }\n        return C;\n    })();\n    exports.C = C;\n});\n\n/// \n\n주의사항: 이 지시자는 더 이상 사용되지 않습니다(deprecated). 대신 import \"moduleName\";문을 사용하세요.\n\n///  결과 모듈의 require 호출에 주입해야하는 non-TS 모듈 의존성에 대해 컴파일러에 알려줍니다.\namd-dependency 지시자는 선택적 name 프로퍼티을 가질 수도 있습니다.이것은 amd-dependency에 선택적 이름을 전달할 수 있습니다:\n/// \ndeclare var moduleA:MyType\nmoduleA.callStuff()\n\n생성된 JS 코드:\ndefine([\"require\", \"exports\", \"legacy/moduleA\"], function (require, exports, moduleA) {\n    moduleA.callStuff()\n});\n\n"},"pages/Type Checking JavaScript Files.html":{"url":"pages/Type Checking JavaScript Files.html","title":"JavaScript 파일 타입 검사","keywords":"","body":"TypeScript 2.3 및 이후 버전에서는 --checkJs를 사용하여 .js 파일에서 타입 검사 및 오류 보고 모드를 지원합니다.\n일부 파일에 // @ts-nocheck 주석을 추가하여 검사하는 것을 건너뛸 수 있습니다.반대로 --checkJs를 설정하지 않고 // @ts-check 주석을 추가하여 몇개의 .js 파일 만 검사하도록 선택할 수 있습니다.앞 줄에 // @ts-ignore를 추가하여 특정 라인의 오류를 무시할 수도 있습니다.\n다음은 .ts 파일에서 .js 파일로 작업하는 방법에 주목할만한 차이점입니다:\nJSDoc에서 타입 사용 (Using types in JSDoc)\n흔히 .js 파일에서 .ts 파일처럼 타입을 추론할 수 있습니다.마찬가지로 타입을 추론할 수 없는 경우 타입 주석을 .ts 파일에서와 같은 방식으로 JSDoc을 사용하여 지정할 수 있습니다.\nJSDoc 주석은 선언을 추가하여 해당 선언의 타입을 설정하는 데 사용됩니다.예를 들어:\n/** @type {number} */\nvar x;\n\nx = 0;      // 좋아요\nx = false;  // 오류: number에 boolean을 할당할 수 없습니다\n\nJavaScript 문서에서 JSDoc 지원에서 지원되는 JSDoc 패턴의 전체 목록을 찾을 수 있습니다.\n클래스 본문 할당에서 추론된 프로퍼티 선언\nES2015/ES6는 클래스에 속성을 선언하는 수단이 없습니다.프로퍼티는 객체 리터럴처럼 동적으로 할당됩니다.\n.js 파일에서 프로퍼티 선언은 클래스 본문 내부의 프로퍼티에 대한 할당에서 유추됩니다.프로퍼티 타입은 이러한 할당에서 모든 오른쪽 값의 타입을 결합한 것입니다.생성자에 정의된 프로퍼티는 항상 존재한다고 가정하며 메서드, getter 또는 setter에 정의된 프로퍼티는 선택적으로 간주합니다.\n필요에 따라 프로퍼티 타입을 지정하기 위해 JSDoc으로 프로퍼티를 할당합니다.예를 들어:\nclass C {\n    constructor() {\n        /** @type {number | undefined} */\n    this.prop = undefined;\n    }\n}\n\n\nlet c = new C();\nc.prop = 0;         // 좋아요\nc.prop = \"string\";  // 오류: number|undefined에 string을 할당할 수 없습니다\n\n프로퍼티가 클래스 본문에 설정되지 않으면 알 수 없는 것으로 간주합니다.클래스에 읽기 전용 프로퍼티가 있는 경우 생성자에서 초기화로 undefined를 추가하는 것이 좋습니다.\n예. this.prop = undefined;\nCommonJS 모듈 입력 지원 (CommonJS module input support)\n.js 파일에서 CommonJS 모듈 포맷은 입력 모듈 포맷으로 허용됩니다.exports와 module.exports에 대한 할당은 export 선언으로 인식됩니다.비슷하게, require 함수 호출은 모듈 imports로 인식됩니다.\n예를 들어:\n// import module \"fs\"\nconst fs = require(\"fs\");\n\n\n// export function readFile\nmodule.exports.readFile = function(f) {\n    return fs.readFileSync(f);    \n}\n\n객체 리터럴에는 제한이 없습니다\n기본적으로 변수 선언에 객체 리터럴은 선언의 타입을 제공합니다.원래 초기화 시에는 지정되지 않은 새 멤버를 추가할 수 없습니다.이 규칙은 .js 파일에서 관대한 편입니다. 객체 리터럴은 원래 정의되지 않은 속성을 추가하고 조회할 수 있는 확장 가능한(open-ended) 타입을 가지고 있습니다.\n예를 들어:\nvar obj = { a: 1 };\nobj.b = 2;  // 허용됨\n\n객체 리터럴은 닫힌 객체가 아닌 오픈 maps으로 처리될 수 있도록 하는 기본 인덱스 시그니처 [x:string]: any을 갖습니다.\n다른 특별한 JS 검사와 마찬가지로, 이 동작은 변수에 대한 JSDoc 타입을 지정하여 변경할 수 있습니다.\n예를 들어:\n/** @type {{a: number}} */\nvar obj = { a: 1 };\nobj.b = 2;  // 오류, {a: number} 타입은 b 프로퍼티를 가지고 있지 않습니다.\n\n함수 매개변수는 기본적으로 선택적입니다. (Function parameters are optional by default)\nJS에서 매개 변수를 선택적으로 지정할 방법이 없기때문에(기본값을 지정하지 않고).js 파일의 모든 함수 매개 변수는 선택사항으로 간주합니다.소수의 인수 호출은 허용됩니다. \n인수가 너무 많은 함수를 호출하는 것은 오류라는 점을 주목하는 것이 중요합니다.\n예를 들어:\nfunction bar(a, b){\n    console.log(a + \" \" + b);\n}\n\nbar(1);       // 좋아요, 두번째 인수는 선택사항으로 간주됩니다\nbar(1, 2);\nbar(1, 2, 3); // 오류, 인수가 너무 많습니다\n\nJSDoc 주석이 적용된 함수는 이 규칙에서 제외됩니다.선택사항을 명시하기 위해 JSDoc 선택적 매개 변수 구문을 사용하세요.\n예:\n/**\n * @param {string} [somebody] - Somebody의 이름\n */\nfunction sayHello(somebody) {\n    if (!somebody) {\n        somebody = 'John Doe';\n    }\n    alert('Hello ' + somebody);\n}\n\nsayHello();\n\narguments의 사용으로 추론된 Var-args 매개변수 (Var-args parameter declaration inferred from use of arguments)\n본문이 arguments 참조에 대한 참조를 갖는 함수는 var-arg 매개변수 (즉,  (...arg: any[]) => any)가 있음을 암시적으로 간주합니다.\nJSDoc var-arg 구문을 사용하여 인수의 타입을 지정하세요.\n지정되지 않은 타입 매개 변수의 기본값은any입니다. (Unspecified type parameters default to any)\n지정되지 않은 제네릭 타입 매개변수는 기본적으로 any로 설정됩니다.이런 일이 발생하는 곳은 거의 없습니다:\nextends에서 (In extends clause):\n예를 들어, React.Component는 Props와 State의 두 가지 제네릭 타입 매개 변수를 갖도록 정의됩니다.\n.js파일에는 extend 절에 이들을 지정하는 합법적 인 방법이 없습니다..js` 파일에는 extend에 이것들을 지정하는 정당한 방법이 없습니다.\n기본적으로 타입 인수는 any입니다:\nimport { Component } from \"react\";\n\nclass MyComponent extends Component {\n    render() {\n       this.props.b; // 허용됨, this.props는 any 타입이므로\n    }\n}\n\nJSDoc@augments를 사용하여 사용하여 타입을 명시적으로 지정합니다.\n예:\nimport { Component } from \"react\";\n\n/**\n * @augments {Component}\n */\nclass MyComponent extends Component {\n    render() {\n        this.props.b; // 오류: b는 {a:number}에 존재하지 않습니다\n    }\n}\n\nJSDoc 참조에서 (In JSDoc references)\nJSDoc의 지정되지 않은 제네릭 타입 인수의 기본값은 any입니다.\n/** @type{Array} */\nvar x = [];\n\nx.push(1);        // 좋아요\nx.push(\"string\"); // 좋아요, x는 Array의 타입입니다\n\n\n/** @type{Array.} */\nvar y = [];\n\ny.push(1);        // 좋아요\ny.push(\"string\"); // 오류, string은 number에 할당할 수 없습니다\n\n함수 호출에서 (In function calls)\n제네릭 함수 호출은 제네릭 타입 매개 변수를 추론하기 위한 인수를 사용합니다.때때로 이 프로세스는 추론 소스가 부족하여 어떤 타입도 추론하지 못하는 경우가 있습니다.이 경우 제네릭 타입 매개 변수는 any로 기본 설정됩니다.\n예를 들어:\nvar p = new Promise((resolve, reject) => { reject() });\n\np; // Promise;\n\n"},"pages/declaration files/Introduction.html":{"url":"pages/declaration files/Introduction.html","title":"소개","keywords":"","body":"이 가이드는 높은 품질의 TypeScript 선언 파일을 작성하는 방법을 설명하기 위해 작성되었습니다.\n이 가이드에서는 TypeScript 언어에 대해 기본적인 지식을 전제로 합니다.아직 읽어 보지 않으셨다면 특히 타입과 네임스페이스와 같은 기본 개념에 \n익숙해지게 하도록 하기 위해 TypeScript 핸드북을 읽어 보시길 바랍니다. \n섹션\n가이드는 다음 섹션으로 나뉩니다.\n라이브러리 구조\n라이브러리 구조 가이드는 일반적인 라이브러리 포맷과 각 포맷에 맞는 선언 파일을 작성하는 방법을 이해할 수 있도록 도와줍니다.기존 파일을 편집하는 경우에는 이 섹션을 읽지 않아도 됩니다.새로운 선언 파일의 작성자는 라이브러리 포맷이 선언 파일의 작성에 어떤 영향을 미치는지를 제대로 이해하기 위해 이 섹션을 읽어야 합니다.\n예제\n대부분, 사용자는 사용자를 안내해 줄 기본적인 라이브러리의 예만 있을 때 선언 파일을 작성하는 것에 직면하게 됩니다.예제 섹션에서는 많은 공통 API 패턴과 각각에 대한 선언을 작성하는 방법을 보여줍니다.이 가이드는 아직 TypeScript의 모든 언어 구조에 익숙하지 않을 수 있는 TypeScript 초보자를 대상으로 합니다.\n\"하세요\"와 \"하지 마세요\"\n선언 파일에서 자주 범하는 실수를 쉽게 피할 수 있습니다.\"하세요\"와 \"하지 마세요\" 섹션에서는 일반적인 오류를 식별합니다,\n  그것들을 감지하는 방법을 기술하고,\n  어떻게 고쳐야하는지.\n모든 사용자들은 일반적인 실수를 피하고자 이 섹션을 읽어야합니다.\n더 깊숙이\n선언 파일이 어떻게 작동하는지에 대한 기본 메커니즘에 관심이 있는 숙련자들을 위해,\n  더 깊숙이 섹션은 선언 작성의 많은 고급 개념을 설명하고 이러한 개념을 활용하여보다 명확하고 직관적인 선언 파일을 작성하는 방법을 설명합니다.\n템플릿\n템플릿에서 새 파일을 작성할 때 유용한 시작점이 되는 여러 선언 파일이 있습니다.어떤 템플릿 파일을 사용할 지 알아 보려면 라이브러리 구조의 문서를 참조하세요.\nnpm 배포\n배포 섹션에서는 선언 파일을 npm 패키지에 배포하는 방법과 의존성 패키지를 관리하는 방법을 설명합니다.\n선언 파일 찾기와 설치\nJavaScript 라이브러리 사용자의 경우 Consumption 섹션에서 해당 선언 파일을 찾아 설치하는 몇 가지 간단한 단계를 제공합니다.\n"},"pages/declaration files/Library Structures.html":{"url":"pages/declaration files/Library Structures.html","title":"Library Structures","keywords":"","body":"Overview\nBroadly speaking, the way you structure your declaration file depends on how the library is consumed.\nThere are many ways of offering a library for consumption in JavaScript, and you'll need to write your declaration file to match it.\nThis guide covers how to identify common library patterns, and how to write declaration files which correspond to that pattern.\nEach type of major library structuring pattern has a corresponding file in the Templates section.\nYou can start with these templates to help you get going faster.\nIdentifying Kinds of Libraries\nFirst, we'll review the kinds of libraries TypeScript declaration files can represent.\nWe'll briefly show how each kind of library is used, how it is written, and list some example libraries from the real world.\nIdentifying the structure of a library is the first step in writing its declaration file.\nWe'll give hints on how to identify structure both based on its usage and its code.\nDepending on the library's documentation and organization, one might be easier than the other.\nWe recommend using whichever is more comfortable to you.\nGlobal Libraries\nA global library is one that can be accessed from the global scope (i.e. without using any form of import).\nMany libraries simply expose one or more global variables for use.\nFor example, if you were using jQuery, the $ variable can be used by simply referring to it:\n$(() => { console.log('hello!'); } );\n\nYou'll usually see guidance in the documentation of a global library of how to use the library in an HTML script tag:\n\n\nToday, most popular globally-accessible libraries are actually written as UMD libraries (see below).\nUMD library documentation is hard to distinguish from global library documentation.\nBefore writing a global declaration file, make sure the library isn't actually UMD.\nIdentifying a Global Library from Code\nGlobal library code is usually extremely simple.\nA global \"Hello, world\" library might look like this:\nfunction createGreeting(s) {\n    return \"Hello, \" + s;\n}\n\nor like this:\nwindow.createGreeting = function(s) {\n    return \"Hello, \" + s;\n}\n\nWhen looking at the code of a global library, you'll usually see:\n\nTop-level var statements or function declarations\nOne or more assignments to window.someName\nAssumptions that DOM primitives like document or window exist\n\nYou won't see:\n\nChecks for, or usage of, module loaders like require or define\nCommonJS/Node.js-style imports of the form var fs = require(\"fs\");\nCalls to define(...)\nDocumentation describing how to require or import the library\n\nExamples of Global Libraries\nBecause it's usually easy to turn a global library into a UMD library, very few popular libraries are still written in the global style.\nHowever, libraries that are small and require the DOM (or have no dependencies) may still be global.\nGlobal Library Template\nThe template file global.d.ts defines an example library myLib.\nBe sure to read the \"Preventing Name Conflicts\" footnote.\nModular Libraries\nSome libraries only work in a module loader environment.\nFor example, because express only works in Node.js and must be loaded using the CommonJS require function.\nECMAScript 2015 (also known as ES2015, ECMAScript 6, and ES6), CommonJS, and RequireJS have similar notions of importing a module.\nIn JavaScript CommonJS (Node.js), for example, you would write\nvar fs = require(\"fs\");\n\nIn TypeScript or ES6, the import keyword serves the same purpose:\nimport fs = require(\"fs\");\n\nYou'll typically see modular libraries include one of these lines in their documentation:\nvar someLib = require('someLib');\n\nor\ndefine(..., ['someLib'], function(someLib) {\n\n});\n\nAs with global modules, you might see these examples in the documentation of a UMD module, so be sure to check the code or documentation.\nIdentifying a Module Library from Code\nModular libraries will typically have at least some of the following:\n\nUnconditional calls to require or define\nDeclarations like import * as a from 'b'; or export c;\nAssignments to exports or module.exports\n\nThey will rarely have:\n\nAssignments to properties of window or global\n\nExamples of Modular Libraries\nMany popular Node.js libraries are in the module family, such as express, gulp, and request.\nUMD\nA UMD module is one that can either be used as module (through an import), or as a global (when run in an environment without a module loader).\nMany popular libraries, such as Moment.js, are written this way.\nFor example, in Node.js or using RequireJS, you would write:\nimport moment = require(\"moment\");\nconsole.log(moment.format());\n\nwhereas in a vanilla browser environment you would write:\nconsole.log(moment.format());\n\nIdentifying a UMD library\nUMD modules check for the existence of a module loader environment.\nThis is an easy-to-spot pattern that looks something like this:\n(function (root, factory) {\n    if (typeof define === \"function\" && define.amd) {\n        define([\"libName\"], factory);\n    } else if (typeof module === \"object\" && module.exports) {\n        module.exports = factory(require(\"libName\"));\n    } else {\n        root.returnExports = factory(root.libName);\n    }\n}(this, function (b) {\n\nIf you see tests for typeof define, typeof window, or typeof module in the code of a library, especially at the top of the file, it's almost always a UMD library.\nDocumentation for UMD libraries will also often demonstrate a \"Using in Node.js\" example showing require,\n  and a \"Using in the browser\" example showing using a  tag to load the script.\nExamples of UMD libraries\nMost popular libraries are now available as UMD packages.\nExamples include jQuery, Moment.js, lodash, and many more.\nTemplate\nThere are three templates available for modules,\n  module.d.ts, module-class.d.ts and module-function.d.ts.\nUse module-function.d.ts if your module can be called like a function:\nvar x = require(\"foo\");\n// Note: calling 'x' as a function\nvar y = x(42);\n\nBe sure to read the footnote \"The Impact of ES6 on Module Call Signatures\"\nUse module-class.d.ts if your module can be constructed using new:\nvar x = require(\"bar\");\n// Note: using 'new' operator on the imported variable\nvar y = new x(\"hello\");\n\nThe same footnote applies to these modules.\nIf your module is not callable or constructable, use the module.d.ts file.\nModule Plugin or UMD Plugin\nA module plugin changes the shape of another module (either UMD or module).\nFor example, in Moment.js, moment-range adds a new range method to the moment object.\nFor the purposes of writing a declaration file, you'll write the same code whether the module being changed is a plain module or UMD module.\nTemplate\nUse the module-plugin.d.ts template.\nGlobal Plugin\nA global plugin is global code that changes the shape of some global.\nAs with global-modifying modules, these raise the possibility of runtime conflict.\nFor example, some libraries add new functions to Array.prototype or String.prototype.\nIdentifying global plugins\nGlobal plugins are generally easy to identify from their documentation.\nYou'll see examples that look like this:\nvar x = \"hello, world\";\n// Creates new methods on built-in types\nconsole.log(x.startsWithHello());\n\nvar y = [1, 2, 3];\n// Creates new methods on built-in types\nconsole.log(y.reverseAndSort());\n\nTemplate\nUse the global-plugin.d.ts template.\nGlobal-modifying Modules\nA global-modifying module alters existing values in the global scope when they are imported.\nFor example, there might exist a library which adds new members to String.prototype when imported.\nThis pattern is somewhat dangerous due to the possibility of runtime conflicts,\n  but we can still write a declaration file for it.\nIdentifying global-modifying modules\nGlobal-modifying modules are generally easy to identify from their documentation.\nIn general, they're similar to global plugins, but need a require call to activate their effects.\nYou might see documentation like this:\n// 'require' call that doesn't use its return value\nvar unused = require(\"magic-string-time\");\n/* or */\nrequire(\"magic-string-time\");\n\nvar x = \"hello, world\";\n// Creates new methods on built-in types\nconsole.log(x.startsWithHello());\n\nvar y = [1, 2, 3];\n// Creates new methods on built-in types\nconsole.log(y.reverseAndSort());\n\nTemplate\nUse the global-modifying-module.d.ts template.\nConsuming Dependencies\nThere are several kinds of dependencies you might have.\nDependencies on Global Libraries\nIf your library depends on a global library, use a ///  directive:\n/// \n\nfunction getThing(): someLib.thing;\n\nDependencies on Modules\nIf your library depends on a module, use an import statement:\nimport * as moment from \"moment\";\n\nfunction getThing(): moment;\n\nDependencies on UMD libraries\nFrom a Global Library\nIf your global library depends on a UMD module, use a ///  directive:\n/// \n\nfunction getThing(): moment;\n\nFrom a Module or UMD Library\nIf your module or UMD library depends on a UMD library, use an import statement:\nimport * as someLib from 'someLib';\n\nDo not use a ///  directive to declare a dependency to a UMD library!\nFootnotes\nPreventing Name Conflicts\nNote that it's possible to define many types in the global scope when writing a global declaration file.\nWe strongly discourage this as it leads to possible unresolvable name conflicts when many declaration files are in a project.\nA simple rule to follow is to only declare types namespaced by whatever global variable the library defines.\nFor example, if the library defines the global value 'cats', you should write\ndeclare namespace cats {\n    interface KittySettings { }\n}\n\nBut not\n// at top-level\ninterface CatsKittySettings { }\n\nThis guidance also ensures that the library can be transitioned to UMD without breaking declaration file users.\nThe Impact of ES6 on Module Plugins\nSome plugins add or modify top-level exports on existing modules.\nWhile this is legal in CommonJS and other loaders, ES6 modules are considered immutable and this pattern will not be possible.\nBecause TypeScript is loader-agnostic, there is no compile-time enforcement of this policy, but developers intending to transition to an ES6 module loader should be aware of this.\nThe Impact of ES6 on Module Call Signatures\nMany popular libraries, such as Express, expose themselves as a callable function when imported.\nFor example, the typical Express usage looks like this:\nimport exp = require(\"express\");\nvar app = exp();\n\nIn ES6 module loaders, the top-level object (here imported as exp) can only have properties;\n  the top-level module object is never callable.\nThe most common solution here is to define a default export for a callable/constructable object;\n  some module loader shims will automatically detect this situation and replace the top-level object with the default export.\n"},"pages/declaration files/By Example.html":{"url":"pages/declaration files/By Example.html","title":"By Example","keywords":"","body":"Introduction\nThe purpose of this guide is to teach you how to write a high-quality definition file.\nThis guide is structured by showing documentation for some API, along with sample usage of that API,\n  and explaining how to write the corresponding declaration.\nThese examples are ordered in approximately increasing order of complexity.\n\nGlobal Variables\nGlobal Functions\nObjects with Properties\nOverloaded Function\nReusable Types (Interfaces)\nReusable Types (Type Aliases)\nOrganizing Types\nClasses\n\nThe Examples\nGlobal Variables\nDocumentation\n\nThe global variable foo contains the number of widgets present.\n\nCode\nconsole.log(\"Half the number of widgets is \" + (foo / 2));\n\nDeclaration\nUse declare var to declare variables.\nIf the variable is read-only, you can use declare const.\nYou can also use declare let if the variable is block-scoped.\n/** The number of widgets present */\ndeclare var foo: number;\n\nGlobal Functions\nDocumentation\n\nYou can call the function greet with a string to show a greeting to the user.\n\nCode\ngreet(\"hello, world\");\n\nDeclaration\nUse declare function to declare functions.\ndeclare function greet(greeting: string): void;\n\nObjects with Properties\nDocumentation\n\nThe global variable myLib has a function makeGreeting for creating greetings,\nand a property numberOfGreetings indicating the number of greetings made so far.\n\nCode\nlet result = myLib.makeGreeting(\"hello, world\");\nconsole.log(\"The computed greeting is:\" + result);\n\nlet count = myLib.numberOfGreetings;\n\nDeclaration\nUse declare namespace to describe types or values accessed by dotted notation.\ndeclare namespace myLib {\n    function makeGreeting(s: string): string;\n    let numberOfGreetings: number;\n}\n\nOverloaded Functions\nDocumentation\nThe getWidget function accepts a number and returns a Widget, or accepts a string and returns a Widget array.\nCode\nlet x: Widget = getWidget(43);\n\nlet arr: Widget[] = getWidget(\"all of them\");\n\nDeclaration\ndeclare function getWidget(n: number): Widget;\ndeclare function getWidget(s: string): Widget[];\n\nReusable Types (Interfaces)\nDocumentation\n\nWhen specifying a greeting, you must pass a GreetingSettings object.\nThis object has the following properties:\n1 - greeting: Mandatory string\n2 - duration: Optional length of time (in milliseconds)\n3 - color: Optional string, e.g. '#ff00ff'\n\nCode\ngreet({\n  greeting: \"hello world\",\n  duration: 4000\n});\n\nDeclaration\nUse an interface to define a type with properties.\ninterface GreetingSettings {\n  greeting: string;\n  duration?: number;\n  color?: string;\n}\n\ndeclare function greet(setting: GreetingSettings): void;\n\nReusable Types (Type Aliases)\nDocumentation\n\nAnywhere a greeting is expected, you can provide a string, a function returning a string, or a Greeter instance.\n\nCode\nfunction getGreeting() {\n    return \"howdy\";\n}\nclass MyGreeter extends Greeter { }\n\ngreet(\"hello\");\ngreet(getGreeting);\ngreet(new MyGreeter());\n\nDeclaration\nYou can use a type alias to make a shorthand for a type:\ntype GreetingLike = string | (() => string) | MyGreeter;\n\ndeclare function greet(g: GreetingLike): void;\n\nOrganizing Types\nDocumentation\n\nThe greeter object can log to a file or display an alert.\nYou can provide LogOptions to .log(...) and alert options to .alert(...)\n\nCode\nconst g = new Greeter(\"Hello\");\ng.log({ verbose: true });\ng.alert({ modal: false, title: \"Current Greeting\" });\n\nDeclaration\nUse namespaces to organize types.\ndeclare namespace GreetingLib {\n    interface LogOptions {\n        verbose?: boolean;\n    }\n    interface AlertOptions {\n        modal: boolean;\n        title?: string;\n        color?: string;\n    }\n}\n\nYou can also create nested namespaces in one declaration:\ndeclare namespace GreetingLib.Options {\n    // Refer to via GreetingLib.Options.Log\n    interface Log {\n        verbose?: boolean;\n    }\n    interface Alert {\n        modal: boolean;\n        title?: string;\n        color?: string;\n    }\n}\n\nClasses\nDocumentation\n\nYou can create a greeter by instantiating the Greeter object, or create a customized greeter by extending from it.\n\nCode\nconst myGreeter = new Greeter(\"hello, world\");\nmyGreeter.greeting = \"howdy\";\nmyGreeter.showGreeting();\n\nclass SpecialGreeter extends Greeter {\n    constructor() {\n        super(\"Very special greetings\");\n    }\n}\n\nDeclaration\nUse declare class to describe a class or class-like object.\nClasses can have properties and methods as well as a constructor.\ndeclare class Greeter {\n    constructor(greeting: string);\n\n    greeting: string;\n    showGreeting(): void;\n}\n\n\n\n*Code*\n\n```ts\n\n```\n\n*Declaration*\n\n```ts\n\n```\n\n-->\n"},"pages/declaration files/Do's and Don'ts.html":{"url":"pages/declaration files/Do's and Don'ts.html","title":"Do's and Don'ts","keywords":"","body":"General Types\nNumber, String, Boolean, and Object\nDon't ever use the types Number, String, Boolean, or Object.\nThese types refer to non-primitive boxed objects that are almost never used appropriately in JavaScript code.\n/* WRONG */\nfunction reverse(s: String): String;\n\nDo use the types number, string, and boolean.\n/* OK */\nfunction reverse(s: string): string;\n\nInstead of Object, use the non-primitive object type (added in TypeScript 2.2).\nGenerics\nDon't ever have a generic type which doesn't use its type parameter.\nSee more details in TypeScript FAQ page.\n\nCallback Types\nReturn Types of Callbacks\n\nDon't use the return type any for callbacks whose value will be ignored:\n/* WRONG */\nfunction fn(x: () => any) {\n    x();\n}\n\nDo use the return type void for callbacks whose value will be ignored:\n/* OK */\nfunction fn(x: () => void) {\n    x();\n}\n\nWhy: Using void is safer because it prevents you from accidently using the return value of x in an unchecked way:\nfunction fn(x: () => void) {\n    var k = x(); // oops! meant to do something else\n    k.doSomething(); // error, but would be OK if the return type had been 'any'\n}\n\nOptional Parameters in Callbacks\nDon't use optional parameters in callbacks unless you really mean it:\n/* WRONG */\ninterface Fetcher {\n    getObject(done: (data: any, elapsedTime?: number) => void): void;\n}\n\nThis has a very specific meaning: the done callback might be invoked with 1 argument or might be invoked with 2 arguments.\nThe author probably intended to say that the callback might not care about the elapsedTime parameter,\n  but there's no need to make the parameter optional to accomplish this --\n  it's always legal to provide a callback that accepts fewer arguments.\nDo write callback parameters as non-optional:\n/* OK */\ninterface Fetcher {\n    getObject(done: (data: any, elapsedTime: number) => void): void;\n}\n\nOverloads and Callbacks\nDon't write separate overloads that differ only on callback arity:\n/* WRONG */\ndeclare function beforeAll(action: () => void, timeout?: number): void;\ndeclare function beforeAll(action: (done: DoneFn) => void, timeout?: number): void;\n\nDo write a single overload using the maximum arity:\n/* OK */\ndeclare function beforeAll(action: (done: DoneFn) => void, timeout?: number): void;\n\nWhy: It's always legal for a callback to disregard a parameter, so there's no need for the shorter overload.\nProviding a shorter callback first allows incorrectly-typed functions to be passed in because they match the first overload.\nFunction Overloads\nOrdering\nDon't put more general overloads before more specific overloads:\n/* WRONG */\ndeclare function fn(x: any): any;\ndeclare function fn(x: HTMLElement): number;\ndeclare function fn(x: HTMLDivElement): string;\n\nvar myElem: HTMLDivElement;\nvar x = fn(myElem); // x: any, wat?\n\nDo sort overloads by putting the more general signatures after more specific signatures:\n/* OK */\ndeclare function fn(x: HTMLDivElement): string;\ndeclare function fn(x: HTMLElement): number;\ndeclare function fn(x: any): any;\n\nvar myElem: HTMLDivElement;\nvar x = fn(myElem); // x: string, :)\n\nWhy: TypeScript chooses the first matching overload when resolving function calls.\nWhen an earlier overload is \"more general\" than a later one, the later one is effectively hidden and cannot be called.\nUse Optional Parameters\nDon't write several overloads that differ only in trailing parameters:\n/* WRONG */\ninterface Example {\n    diff(one: string): number;\n    diff(one: string, two: string): number;\n    diff(one: string, two: string, three: boolean): number;\n}\n\nDo use optional parameters whenever possible:\n/* OK */\ninterface Example {\n    diff(one: string, two?: string, three?: boolean): number;\n}\n\nNote that this collapsing should only occur when all overloads have the same return type.\nWhy: This is important for two reasons.\nTypeScript resolves signature compatibility by seeing if any signature of the target can be invoked with the arguments of the source,\n  and extraneous arguments are allowed.\nThis code, for example, exposes a bug only when the signature is correctly written using optional parameters:\nfunction fn(x: (a: string, b: number, c: number) => void) { }\nvar x: Example;\n// When written with overloads, OK -- used first overload\n// When written with optionals, correctly an error\nfn(x.diff);\n\nThe second reason is when a consumer uses the \"strict null checking\" feature of TypeScript.\nBecause unspecified parameters appear as undefined in JavaScript, it's usually fine to pass an explicit undefined to a function with optional arguments.\nThis code, for example, should be OK under strict nulls:\nvar x: Example;\n// When written with overloads, incorrectly an error because of passing 'undefined' to 'string'\n// When written with optionals, correctly OK\nx.diff(\"something\", true ? undefined : \"hour\");\n\nUse Union Types\nDon't write overloads that differ by type in only one argument position:\n/* WRONG */\ninterface Moment {\n    utcOffset(): number;\n    utcOffset(b: number): Moment;\n    utcOffset(b: string): Moment;\n}\n\nDo use union types whenever possible:\n/* OK */\ninterface Moment {\n    utcOffset(): number;\n    utcOffset(b: number|string): Moment;\n}\n\nNote that we didn't make b optional here because the return types of the signatures differ.\nWhy: This is important for people who are \"passing through\" a value to your function:\nfunction fn(x: string): void;\nfunction fn(x: number): void;\nfunction fn(x: number|string) {\n    // When written with separate overloads, incorrectly an error\n    // When written with union types, correctly OK\n    return moment().utcOffset(x);\n}\n\n"},"pages/declaration files/Deep Dive.html":{"url":"pages/declaration files/Deep Dive.html","title":"Deep Dive","keywords":"","body":"Definition File Theory: A Deep Dive\nStructuring modules to give the exact API shape you want can be tricky.\nFor example, we might want a module that can be invoked with or without new to produce different types,\n  has a variety of named types exposed in a hierarchy,\n  and has some properties on the module object as well.\nBy reading this guide, you'll have the tools to write complex definition files that expose a friendly API surface.\nThis guide focuses on module (or UMD) libraries because the options here are more varied.\nKey Concepts\nYou can fully understand how to make any shape of definition\n  by understanding some key concepts of how TypeScript works.\nTypes\nIf you're reading this guide, you probably already roughly know what a type in TypeScript is.\nTo be more explicit, though, a type is introduced with:\n\nA type alias declaration (type sn = number | string;)\nAn interface declaration (interface I { x: number[]; })\nA class declaration (class C { })\nAn enum declaration (enum E { A, B, C })\nAn import declaration which refers to a type\n\nEach of these declaration forms creates a new type name.\nValues\nAs with types, you probably already understand what a value is.\nValues are runtime names that we can reference in expressions.\nFor example let x = 5; creates a value called x.\nAgain, being explicit, the following things create values:\n\nlet, const, and var declarations\nA namespace or module declaration which contains a value\nAn enum declaration\nA class declaration\nAn import declaration which refers to a value\nA function declaration\n\nNamespaces\nTypes can exist in namespaces.\nFor example, if we have the declaration let x: A.B.C,\n  we say that the type C comes from the A.B namespace.\nThis distinction is subtle and important -- here, A.B is not necessarily a type or a value.\nSimple Combinations: One name, multiple meanings\nGiven a name A, we might find up to three different meanings for A: a type, a value or a namespace.\nHow the name is interpreted depends on the context in which it is used.\nFor example, in the declaration let m: A.A = A;,\n  A is used first as a namespace, then as a type name, then as a value.\nThese meanings might end up referring to entirely different declarations!\nThis may seem confusing, but it's actually very convenient as long as we don't excessively overload things.\nLet's look at some useful aspects of this combining behavior.\nBuilt-in Combinations\nAstute readers will notice that, for example, class appeared in both the type and value lists.\nThe declaration class C { } creates two things:\n  a type C which refers to the instance shape of the class,\n  and a value C which refers to the constructor function of the class.\nEnum declarations behave similarly.\nUser Combinations\nLet's say we wrote a module file foo.d.ts:\nexport var SomeVar: { a: SomeType };\nexport interface SomeType {\n  count: number;\n}\n\nThen consumed it:\nimport * as foo from './foo';\nlet x: foo.SomeType = foo.SomeVar.a;\nconsole.log(x.count);\n\nThis works well enough, but we might imagine that SomeType and SomeVar were very closely related\n  such that you'd like them to have the same name.\nWe can use combining to present these two different objects (the value and the type) under the same name Bar:\nexport var Bar: { a: Bar };\nexport interface Bar {\n  count: number;\n}\n\nThis presents a very good opportunity for destructuring in the consuming code:\nimport { Bar } from './foo';\nlet x: Bar = Bar.a;\nconsole.log(x.count);\n\nAgain, we've used Bar as both a type and a value here.\nNote that we didn't have to declare the Bar value as being of the Bar type -- they're independent.\nAdvanced Combinations\nSome kinds of declarations can be combined across multiple declarations.\nFor example, class C { } and interface C { } can co-exist and both contribute properties to the C types.\nThis is legal as long as it does not create a conflict.\nA general rule of thumb is that values always conflict with other values of the same name unless they are declared as namespaces,\n  types will conflict if they are declared with a type alias declaration (type s = string),\n  and namespaces never conflict.\nLet's see how this can be used.\nAdding using an interface\nWe can add additional members to an interface with another interface declaration:\ninterface Foo {\n  x: number;\n}\n// ... elsewhere ...\ninterface Foo {\n  y: number;\n}\nlet a: Foo = ...;\nconsole.log(a.x + a.y); // OK\n\nThis also works with classes:\nclass Foo {\n  x: number;\n}\n// ... elsewhere ...\ninterface Foo {\n  y: number;\n}\nlet a: Foo = ...;\nconsole.log(a.x + a.y); // OK\n\nNote that we cannot add to type aliases (type s = string;) using an interface.\nAdding using a namespace\nA namespace declaration can be used to add new types, values, and namespaces in any way which does not create a conflict.\nFor example, we can add a static member to a class:\nclass C {\n}\n// ... elsewhere ...\nnamespace C {\n  export let x: number;\n}\nlet y = C.x; // OK\n\nNote that in this example, we added a value to the static side of C (its constructor function).\nThis is because we added a value, and the container for all values is another value\n  (types are contained by namespaces, and namespaces are contained by other namespaces).\nWe could also add a namespaced type to a class:\nclass C {\n}\n// ... elsewhere ...\nnamespace C {\n  export interface D { }\n}\nlet y: C.D; // OK\n\nIn this example, there wasn't a namespace C until we wrote the namespace declaration for it.\nThe meaning C as a namespace doesn't conflict with the value or type meanings of C created by the class.\nFinally, we could perform many different merges using namespace declarations.\nThis isn't a particularly realistic example, but shows all sorts of interesting behavior:\nnamespace X {\n  export interface Y { }\n  export class Z { }\n}\n\n// ... elsewhere ...\nnamespace X {\n  export var Y: number;\n  export namespace Z {\n    export class C { }\n  }\n}\ntype X = string;\n\nIn this example, the first block creates the following name meanings:\n\nA value X (because the namespace declaration contains a value, Z)\nA namespace X (because the namespace declaration contains a type, Y)\nA type Y in the X namespace\nA type Z in the X namespace (the instance shape of the class)\nA value Z that is a property of the X value (the constructor function of the class)\n\nThe second  block creates the following name meanings:\n\nA value Y (of type number) that is a property of the X value\nA namespace Z\nA value Z that is a property of the X value\nA type C in the X.Z namespace\nA value C that is a property of the X.Z value\nA type X\n\nUsing with export = or import\nAn important rule is that export and import declarations export or import all meanings of their targets.\n\n"},"pages/declaration files/Templates.html":{"url":"pages/declaration files/Templates.html","title":"Templates","keywords":"","body":"\nglobal-modifying-module.d.ts\nglobal-plugin.d.ts\nglobal.d.ts\nmodule-class.d.ts\nmodule-function.d.ts\nmodule-plugin.d.ts\nmodule.d.ts\n\n"},"pages/declaration files/Publishing.html":{"url":"pages/declaration files/Publishing.html","title":"Publishing","keywords":"","body":"Now that you have authored a declaration file following the steps of this guide, it is time to publish it to npm.\nThere are two main ways you can publish your declaration files to npm:\n\nbundling with your npm package, or\npublishing to the @types organization on npm.\n\nIf your package is written in TypeScript then the first approach is favored.\nUse the --declaration flag to generate declaration files.\nThis way, your declarations and JavaScript always be in sync.\nIf your package is not written in TypeScript then the second is the prefered approch.\nIncluding declarations in your npm package\nIf your package has a main .js file, you will need to indicate the main declaration file in your package.json file as well.\nSet the types property to point to your bundled declaration file.\nFor example:\n{\n    \"name\": \"awesome\",\n    \"author\": \"Vandelay Industries\",\n    \"version\": \"1.0.0\",\n    \"main\": \"./lib/main.js\",\n    \"types\": \"./lib/main.d.ts\"\n}\n\nNote that the \"typings\" field is synonymous with \"types\", and could be used as well.\nAlso note that if your main declaration file is named index.d.ts and lives at the root of the package (next to index.js) you do not need to mark the \"types\" property, though it is advisable to do so.\nDependencies\nAll dependencies are managed by npm.\nMake sure all the declaration packages you depend on are marked appropriately in the \"dependencies\" section in your package.json.\nFor example, imagine we authored a package that used Browserify and TypeScript.\n{\n    \"name\": \"browserify-typescript-extension\",\n    \"author\": \"Vandelay Industries\",\n    \"version\": \"1.0.0\",\n    \"main\": \"./lib/main.js\",\n    \"types\": \"./lib/main.d.ts\",\n    \"dependencies\": {\n        \"browserify\": \"latest\",\n        \"@types/browserify\": \"latest\",\n        \"typescript\": \"next\"\n    }\n}\n\nHere, our package depends on the browserify and typescript packages.\nbrowserify does not bundle its declaration files with its npm packages, so we needed to depend on @types/browserify for its declarations.\ntypescript, on the other hand, packages its declaration files, so there was no need for any additional dependencies\nOur package exposes declarations from each of those, so any user of our browserify-typescript-extension package needs to have these dependencies as well.\nFor that reason, we used \"dependencies\" and not \"devDependencies\", because otherwise our consumers would have needed to manually install those packages.\nIf we had just written a command line application and not expected our package to be used as a library, we might have used devDependencies.\nRed flags\n/// \nDon't use ///  in your declaration files.\n/// \n....\n\nDo use ///  instead.\n/// \n....\n\nMake sure to revisit the Consuming dependencies section for more information.\nPackaging dependent declarations\nIf your type definitions depend on another package:\n\nDon't combine it with yours, keep each in their own file.\nDon't copy the declarations in your package either.\nDo depend on the npm type declaration package if it doesn't package its declaration files.\n\nPublish to @types\nPackages on under the @types organization are published automatically from DefinitelyTyped using the types-publisher tool.\nTo get your declarations published as an @types package, please submit a pull request to https://github.com/DefinitelyTyped/DefinitelyTyped.\nYou can find more details in the contribution guidelines page.\n"},"pages/declaration files/Consumption.html":{"url":"pages/declaration files/Consumption.html","title":"Consumption","keywords":"","body":"In TypeScript 2.0, it has become significantly easier to consume declaration files, in acquiring, using, and finding them.\nThis page details exactly how to do all three.\nDownloading\nGetting type declarations in TypeScript 2.0 and above requires no tools apart from npm.\nAs an example, getting the declarations for a library like lodash takes nothing more than the following command\nnpm install --save @types/lodash\n\nIt is worth noting that if the npm package already includes its declaration file as described in Publishing, downloading the corresponding @types package is not needed.\nConsuming\nFrom there you’ll be able to use lodash in your TypeScript code with no fuss.\nThis works for both modules and global code.\nFor example, once you’ve npm install-ed your type declarations, you can use imports and write\nimport * as _ from \"lodash\";\n_.padStart(\"Hello TypeScript!\", 20, \" \");\n\nor if you’re not using modules, you can just use the global variable _.\n_.padStart(\"Hello TypeScript!\", 20, \" \");\n\nSearching\nFor the most part, type declaration packages should always have the same name as the package name on npm, but prefixed with @types/,\n  but if you need, you can check out https://aka.ms/types to find the package for your favorite library.\n\nNote: if the declaration file you are searching for is not present, you can always contribute one back and help out the next developer looking for it.\nPlease see the DefinitelyTyped contribution guidelines page for details.\n\n"},"pages/tsconfig.json.html":{"url":"pages/tsconfig.json.html","title":"tsconfig.json","keywords":"","body":"개요\n디렉토리에 tsconfig.json 파일이 존재한다는 것은 해당 디렉토리가 TypeScript 프로젝트의 루트임을 나타냅니다.tsconfig.json 파일은 프로젝트를 컴파일하는 데 필요한 루트 파일과 컴파일러 옵션을 지정합니다.\n프로젝트는 다음 방법 중 하나로 컴파일됩니다:\ntsconfig.json 사용\n\n입력 파일 없이 tsc를 호출하는 경우 컴파일러는 현재 디렉토리에서부터 시작하여 상위 디렉토리 체인으로 이어지며 tsconfig.json 파일을 검색합니다.\n입력 파일이 없는 tsc와 tsconfig.json 파일이 포함된 디렉토리의 경로를 지정하는 --project (또는 -p) 커맨드 라인 옵션을 호출하거나 유효한 경로의 .json 파일에 설정이 포함되어 있습니다.\n\n커맨드 라인에 입력 파일을 지정하면 tsconfig.json 파일이 무시됩니다.\n예제\ntsconfig.json 예제 파일들:\n\n\"files\" 속성 사용\n{\n    \"compilerOptions\": {\n        \"module\": \"commonjs\",\n        \"noImplicitAny\": true,\n        \"removeComments\": true,\n        \"preserveConstEnums\": true,\n        \"sourceMap\": true\n    },\n    \"files\": [\n        \"core.ts\",\n        \"sys.ts\",\n        \"types.ts\",\n        \"scanner.ts\",\n        \"parser.ts\",\n        \"utilities.ts\",\n        \"binder.ts\",\n        \"checker.ts\",\n        \"emitter.ts\",\n        \"program.ts\",\n        \"commandLineParser.ts\",\n        \"tsc.ts\",\n        \"diagnosticInformationMap.generated.ts\"\n    ]\n}\n\n\n\"include\" 및 \"exclude\" 속성 사용\n{\n    \"compilerOptions\": {\n        \"module\": \"system\",\n        \"noImplicitAny\": true,\n        \"removeComments\": true,\n        \"preserveConstEnums\": true,\n        \"outFile\": \"../../built/local/tsc.js\",\n        \"sourceMap\": true\n    },\n    \"include\": [\n        \"src/**/*\"\n    ],\n    \"exclude\": [\n        \"node_modules\",\n        \"**/*.spec.ts\"\n    ]\n}\n\n\n\n상세 설명\n\"compilerOptions\" 속성은 생략될 수 있으며 이 경우 컴파일러의 기본 값이 사용됩니다.지원되는 컴파일러 옵션의 전체 목록보기\n\"files\" 속성은 상대적이거나 절대적인 파일 경로 목록을 갖습니다.\"include\"와 \"exclude\"는 glob 파일 패턴의 목록과 같은 속성을 갖습니다.지원되는 glob 와일드카드는 다음과 같습니다:\n\n* 0개 이상의 문자와 매칭 (디렉토리 separator 제외)\n? 한 문자와 매칭 (디렉토리 separator 제외)\n**/ 반복적으로 모든 하위 디렉토리와 매칭\n\nglob 패턴의 구분에 * 또는 . *만 있는 경우, 지원하는 확장자 파일만 포함됩니다 (예: 기본적으로는 .ts, .tsx 및 .d.ts / allowJs true로 설정시 .js와 .jsx).\n\"files\"과 \"include\" 모두 지정되어 있지 않을 경우 컴파일러는 기본적으로 모든 TypeScript (.ts,.d.ts 그리고 .tsx) 파일을 포함하는 디렉토리와 하위 디렉토리에 포함시킵니다.\"exclude\" 속성을 사용하여 제외된 것은 제외합니다.allowJs가 true로 설정되면 JS 파일(.js와 .jsx)도 포함됩니다.\n\"files\"과 \"include\" 모두 지정되어 있는 경우 컴파일러는 그 두 속성에 포함된 파일의 결합(union)을 대신 포함합니다.\"outDir\" 컴파일러 옵션을 사용하여 지정된 디렉토리의 파일들은 \"exclude\" 속성이 지정되지 않은 한 제외됩니다.\n\"include\"을 사용하여 포함된 파일들은 \"exclude\" 속성을 사용해 필터링할 수 있습니다.그러나 \"files\" 속성을 명시적으로 사용하는 파일은 \"exclude\"에 관계없이 항상 포함됩니다.\"exclude\" 속성에 디렉토리가 지정되지 있지 않을 경우 node_modules, bower_components, jspm_packages 그리고 를 제외합니다.\n\"files\" 또는 \"include\" 속성을 통해 파일에 참조되는 모든 파일도 포함됩니다.  \n비슷하게, 파일 B.ts가 또 다른 파일 A.ts에 의해 참조되는 경우, B.ts는 참조 파일 A.ts가 \"exclude\" 리스트에서도 지정되지 않는 한 제외될 수 없습니다.\n컴파일러에는 실행할 수 있는 출력 파일이 포함되어 있지 않다는 점에 주의해야 합니다.즉 입력에 index.ts가 포함되면 index.d.ts와 index.js는 제외됩니다.일반적으로 파일이 확장자만 다르게 나란히 있는 것은 권장하지 않습니다.\ntsconfig.json 파일은 완전히 비어있을 수 있습니다.기본 컴파일러 옵션으로 기본적인(위에서 설명한대로) 포함된 모든 파일을 컴파일합니다.\n기본 컴파일러 옵션으로 기본적으로(위에서 설명한대로) 모든 파일을 컴파일하는 것이 tsconfig.json파일을 완전히 비워 두는 것을 허용하십시오.\n커맨드 라인에 지정된 컴파일러 옵션은 tsconfig.json 파일에 지정된 옵션을 오버라이드합니다.\n@types, typeRoots 및 types\n기본적으로 표시된 모든 \"@types\" 패키지가 컴파일에 포함됩니다.동봉된 모든 폴더의 node_modules/@types 패키지는 표시된 것으로 간주됩니다.구체적으로 ./node_modules/@types/,  ../node_modules/@types/, ../../node_modules/@types/ 등의 패키지를 의미합니다.\ntypeRoots를 지정하면 typeRoots 아래에 있는 패키지만 포함됩니다.\n예를 들어\n{\n   \"compilerOptions\": {\n       \"typeRoots\" : [\"./typings\"]\n   }\n}\n\n이 설정 파일에는 ./typings의 모든 패키지가 포함되며 ./node_modules/@types의 패키지는 포함되지 않습니다.\ntypes을 지정할 경우 나열된 패키지만 포함됩니다.\n예를 들어:\n{\n   \"compilerOptions\": {\n       \"types\" : [\"node\", \"lodash\", \"express\"]\n   }\n}\n\n이 tsconfig.json은 오직 ./node_modules/@types/node, ./node_modules/@types/lodash 및 ./node_modules/@types/express만 포함합니다.node_modules/@types/* 아래의 다른 패키지는 포함되지 않습니다.\ntypes 패키지는 index.d.ts 파일이 있는 폴더 또는 폴더에 types 필드를 가진 package.json가 있는 폴더입니다.\n\"types\": []를 지정하면 @types 패키지가 자동으로 포함되지 않습니다.\n전역 선언이 포함된 파일을 사용하는 경우에만 자동 포함이 중요하다는 점에 명심하세요 (모듈로 선언된 파일과 달리).예를 들어 import \"foo\" 문을 사용한다면 TypeScript는 여전히 node_modules & node_modules/@types 폴더를 보고 foo 패키지를 찾을 것입니다. \nextends를 이용한 설정 상속 (Configuration inheritance with extends)\ntsconfig.json 파일은 extends 속성을  사용해 다른 파일의 설정을 상속할 수 있습니다.\nextends는 tsconfig.json의 최상위 속성 (compilerOptions,files,include 및 exclude와 함께) 입니다.extends' 값은 상속받을 다른 설정 파일의 경로를 포함하는 문자열입니다.\n기본 파일의 설정이 먼저 로드된 다음 상속되는 설정 파일의 설정에 의해 재정의됩니다.순환성 장애와 맞닥뜨리면 오류를 보고합니다.상속 설정 파일에서 files, include 및 exclude는 기본 설정 파일을 덮어씁니다.\n설정 파일에 있는 모든 상대적 경로는 해당 경로가 원래 있던 설정 파일을 기준으로 해석됩니다.\n예를 들어:\nconfigs/base.json:\n{\n  \"compilerOptions\": {\n    \"noImplicitAny\": true,\n    \"strictNullChecks\": true\n  }\n}\n\ntsconfig.json:\n{\n  \"extends\": \"./configs/base\",\n  \"files\": [\n    \"main.ts\",\n    \"supplemental.ts\"\n  ]\n}\n\ntsconfig.nostrictnull.json:\n{\n  \"extends\": \"./tsconfig\",\n  \"compilerOptions\": {\n    \"strictNullChecks\": false\n  }\n}\n\ncompileOnSave\n최상위 속성 compileOnSave를 IDE에 설정하면 저장 시 지정된 tsconfig.json에 대한 모든 파일을 생성합니다.\n{\n   \"compileOnSave\": true,\n   \"compilerOptions\": {\n       \"noImplicitAny\" : true\n   }\n}\n\n이 기능은 현재 TypeScript 1.8.4 이상과 atom-typescript 플러그인이 있는 Visual Studio 2015에서 지원됩니다.\n스키마\n스키마는 http://json.schemastore.org/tsconfig에서 찾을 수 있습니다.\n"},"pages/Compiler Options.html":{"url":"pages/Compiler Options.html","title":"컴파일러 옵션","keywords":"","body":"컴파일러 옵션\n\n\n\n옵션\n타입\n기본값\n설명\n\n\n\n\n--allowJs\nboolean\nfalse\nJavaScript 파일 컴파일 허용합니다\n\n\n--allowSyntheticDefaultImports\nboolean\nmodule === \"system\"\ndefault export가 없는 모듈에서 default imports를 허용합니다. 코드 방출에는 영향을 주지 않으며 단지 타입 검사에 불과합니다.\n\n\n--allowUnreachableCode\nboolean\nfalse\n연결할 수 없는 코드에 대한 오류를 보고하지 않습니다.\n\n\n--allowUnusedLabels\nboolean\nfalse\n사용되지 않는 레이블에 대한 오류 보고하지 않습니다.\n\n\n--alwaysStrict\nboolean\nfalse\n각 소스 파일에 대해 strict 모드로 구문 파싱을 하고 \"use strict\"을 내보냅니다.\n\n\n--baseUrl\nstring\n\n비-상대적 모듈 이름을 해석하기 위한 기본 디렉토리. 자세한 내용은 모듈 해석 문서을 참조하세요.\n\n\n--charset\nstring\n\"utf8\"\n입력 파일의 문자열 집합입니다 (인코딩 관련).\n\n\n--checkJs\nboolean\nfalse\n.js 파일에 오류를 보고합니다. --allowJs와 함께 사용하세요.\n\n\n--declaration-d\nboolean\nfalse\n해당하는 .d.ts 파일을 생성합니다.\n\n\n--declarationDir\nstring\n\n생성된 선언 파일의 출력 디렉토리입니다.\n\n\n--diagnostics\nboolean\nfalse\n진단 정보를 보여줍니다.\n\n\n--disableSizeLimit\nboolean\nfalse\nJavaScript 프로젝트의 사이즈 제한을 중지합니다.\n\n\n--downlevelIteration\nboolean\nfalse\nES5 또는 ES3를 대상으로 할 때 for..of, spread 및 destructuring 반복 가능한 iterables 지원을 제공합니다.\n\n\n--emitBOM\nboolean\nfalse\n출력 파일의 시작 부분에 UTF-8 바이트 순서표(BOM)를 내보냅니다.\n\n\n--emitDecoratorMetadata[1]\nboolean\nfalse\n소스에 데코레이터 선언에 대한 설계 타입 메타 데이터를 내보냅니다. 자세한 내용은 #2577 이슈을 참조하세요.\n\n\n--experimentalDecorators[1]\nboolean\nfalse\nES 데코레이터에 대한 실험적인 지원을 사용하도록 활성화합니다.\n\n\n--forceConsistentCasingInFileNames\nboolean\nfalse\n동일한 파일에 대해 일관성이 없는 참조는 허용하지 않습니다.\n\n\n--help-h\n\n\n도움말을 출력합니다.\n\n\n--importHelpers\nboolean\nfalse\n방출된 헬퍼를 임포트합니다. tslib로부터 (예. __extends, __rest, 등..)\n\n\n--inlineSourceMap\nboolean\nfalse\n별도의 파일 대신 소스 맵으로 단일 파일을 내보냅니다.\n\n\n--inlineSources\nboolean\nfalse\n단일 파일 내에서 소스 맵과 함께 소스를 내보냅니다. --inlineSourceMap 또는 --sourceMap을 설정해야 합니다.\n\n\n--init\n\n\nTypeScript 프로젝트를 초기화하고 tsconfig.json 파일을 생성합니다.\n\n\n--isolatedModules\nboolean\nfalse\n각 파일을 별도의 모듈로 불리하여 변환합니다 (\"ts.transpileModule\"과 비슷합니다).\n\n\n--jsx\nstring\n\"Preserve\"\n.tsx 파일에서 JSX 지원: \"React\" 또는 \"Preserve\". JSX를 확인하세요.\n\n\n--jsxFactory\nstring\n\"React.createElement\"\n리액트 JSX 방출을 대상으로 할 때 사용할 JSX 팩토리 함수를 지정합니다. 예: React.createElement 또는 h.\n\n\n--lib\nstring[]\n\n컴파일에 포함될 라이브러리 파일 목록입니다.가능한 값은 다음과 같습니다:  ► ES5 ► ES6 ► ES2015 ► ES7 ► ES2016 ► ES2017 ► ESNext ► DOM ► DOM.Iterable ► WebWorker ► ScriptHost ► ES2015.Core ► ES2015.Collection ► ES2015.Generator ► ES2015.Iterable ► ES2015.Promise ► ES2015.Proxy ► ES2015.Reflect ► ES2015.Symbol ► ES2015.Symbol.WellKnown ► ES2016.Array.Include ► ES2017.object ► ES2017.SharedMemory ► ES2017.TypedArrays ► esnext.asynciterable ► esnext.promise  주의사항: --lib가 지정되지 않으면 라이브러리의 기본 리스트가 삽입됩니다. 주입되는 기본 라이브러리는 다음과 같습니다:   ► --target ES5: DOM,ES5,ScriptHost  ► --target ES6: DOM,ES6,DOM.Iterable,ScriptHost\n\n\n--listEmittedFiles\nboolean\nfalse\n컴파일의 일부로 생성된 파일의 이름을 출력합니다.\n\n\n--listFiles\nboolean\nfalse\n컴파일에 포함된 파일의 이름을 출력합니다.\n\n\n--locale\nstring\n(특정 플랫폼)\n오류 메시지를 표시하는 데 사용할 지역화, 예: en-us. 가능한 값은 다음과 같습니다:  ► English (US): en ► Czech: cs ► German: de ► Spanish: es ► French: fr ► Italian: it ► Japanese: ja ► Korean: ko ► Polish: pl ► Portuguese(Brazil): pt-BR ► Russian: ru ► Turkish: tr ► Simplified Chinese: zh-CN  ► Traditional Chinese: zh-TW\n\n\n--mapRoot\nstring\n\n디버거가 생성된 위치가 아닌 맵 파일의 위치를 지정합니다. .map 파일이 .js 파일과 다른 위치에 런타임 시 위치할 경우 이 옵션을 사용하세요. 지정된 위치는 sourceMap에 포함되어 맵 파일이 위치할 디버거를 지정합니다.\n\n\n--maxNodeModuleJsDepth\nnumber\n0\nnode_modules 및 로드 JavaScript 파일 아래에서 검색할 최대 의존성 깊이. --allowJs에만 적용됩니다.\n\n\n--module-m\nstring\ntarget === \"ES3\" or \"ES5\" ? \"CommonJS\" : \"ES6\"\n모듈 코드 생성 지정: \"None\", \"CommonJS\", \"AMD\", \"System\", \"UMD\", \"ES6\", \"ES2015\" 또는 \"ESNext\".► \"AMD\"와 \"System\"만 --outFile과 함께 사용할 수 있습니다.► \"ES6\"와 \"ES2015\" 값은 \"ES5\" 또는 이하를 대상으로 할 때 사용할 수 있습니다.\n\n\n--moduleResolution\nstring\nmodule === \"AMD\" or \"System\" or \"ES6\" ?  \"Classic\" : \"Node\"\n모듈 해석 방법 결정. Node.js/io.js 스타일 해석의 경우, \"Node\" 또는 \"Classic\" 중 하나입니다. 자세한 내용은 모듈 해석 문서를 참조하세요.\n\n\n--newLine\nstring\n(특정 플랫폼)\n파일을 내보낼 때 사용되는 지정된 라인 끝의 시퀀스 사용: \"crlf\" (윈도우) 또는 \"lf\" (유닉스).\"\n\n\n--noEmit\nboolean\nfalse\n출력을 내보내지 않습니다.\n\n\n--noEmitHelpers\nboolean\nfalse\n컴파일된 출력에서는 __extends와 같은 커스텀 헬퍼 함수를 생성하지 않습니다.\n\n\n--noEmitOnError\nboolean\nfalse\n오류가 보고된 경우 출력을 내보내지 않습니다.\n\n\n--noErrorTruncation\nboolean\nfalse\n오류 메세지를 줄이지 않습니다.\n\n\n--noFallthroughCasesInSwitch\nboolean\nfalse\n스위치 문에 fallthrough 케이스에 대한 오류를 보고합니다.\n\n\n--noImplicitAny\nboolean\nfalse\nany 타입으로 암시한 표현식과 선언에 오류를 발생시킵니다.\n\n\n--noImplicitReturns\nboolean\nfalse\n함수의 모든 코드 경로에 반환값이 없을 때 오류를 보고합니다.\n\n\n--noImplicitThis\nboolean\nfalse\nany 타입으로 암시한 this 표현식에 오류를 보고합니다.\n\n\n--noImplicitUseStrict\nboolean\nfalse\n모듈 출력에 \"use strict\" 지시자를 내보내지 않습니다.\n\n\n--noLib\nboolean\nfalse\n기본 라이브러리 파일(lib.d.ts)은 포함하지 않습니다.\n\n\n--noResolve\nboolean\nfalse\n컴파일된 파일 목록에 트리플-슬래시 참조 또는 모듈 임포트 대상을 추가하지 않습니다.\n\n\n--noStrictGenericChecks\nboolean\nfalse\n함수 타입에서 제네릭 시그니처의 엄격한 검사를 비활성화합니다.\n\n\n--noUnusedLocals\nboolean\nfalse\n사용하지 않는 지역 변수에 대한 오류를 보고합니다.\n\n\n--noUnusedParameters\nboolean\nfalse\n사용하지 않는 매개 변수에 대한 오류를 보고합니다.\n\n\n--out\nstring\n\nDEPRECATED 되었습니다. --outFile을 대신 사용합니다.\n\n\n--outDir\nstring\n\n출력 구조를 디렉토리로 리다이렉트합니다.\n\n\n--outFile\nstring\n\n출력을 단일 파일로 연결하여 방출합니다. 연결의 순서는 컴파일러에 전달된 파일 목록과 트리플-슬래시 참조 그리고 임포트와 함께 결정됩니다. 자세한 내용은 출력 파일 순서 문서를 참조하세요.\n\n\npaths[2]\nObject\n\nbaseUrl을 기준으로 관련된 위치에 모듈 이름의 경로 매핑 목록을 나열합니다. 자세한 내용은 모듈 해석 문서를 참조하세요.\n\n\n--preserveConstEnums\nboolean\nfalse\n생성된 코드에 const enum 선언을 지우지 않습니다. 자세한 내용은 const 열거형 문서를 참조하세요.\n\n\n--preserveSymlinks\nboolean\nfalse\nsymlinks를 실제 경로로 해석하지 않습니다. symlinked된 파일을 실제 파일처럼 다룹니다.\n\n\n--pretty[1]\nboolean\nfalse\n색상 및 컨텍스트를 사용하여 오류 및 메세지 스타일을 지정합니다.\n\n\n--project-p\nstring\n\n유효한 설정 파일이 지정된 프로젝트를 컴파일하세요.이 인수는 유효한 JSON 설정 파일의 파일 경로일 수도 있고 tsconfig.json 파일이 포함된 디렉토리의 경로일 수도 있습니다.자세한 내용은 tsconfig.json를 참조하세요.\n\n\n--reactNamespace\nstring\n\"React\"\nDEPRECATED 되었습니다. --jsxFactory를 대신 사용합니다.\"react\" JSX emit을 대상으로 할 때 createElement와 __spread에 호출된 객체를 지정합니다.\n\n\n--removeComments\nboolean\nfalse\n/*!로 시작하는 copy-right 헤더 주석을 제외한 모든 주석을 제거합니다.\n\n\n--rootDir\nstring\n(공통 루트 디렉토리는 input files 리스트에서 처리됩니다)\n입력 파일의 루트 디렉토리를 지정합니다. --outDir로 출력 디렉토리 구조를 제어하기 위해서만 사용합니다.\n\n\nrootDirs[2]\nstring[]\n\n런타임 시 결합된 컨텐츠가 프로젝트의 구조를 나타내는 루트 폴더 목록입니다. 자세한 내용은 모듈 해석 문서를 참조하세요.\n\n\n--skipDefaultLibCheck\nboolean\nfalse\nDEPRECATED 되었습니다. --skipLibCheck를 대신 사용합니다.기본 라이브러리 선언 파일의 타입 검사 건너뛰기[default library declaration files].\n\n\n--skipLibCheck\nboolean\nfalse\n모든 선언 파일(*.d.ts)의 타입 검사를 건너뜁니다.\n\n\n--sourceMap\nboolean\nfalse\n해당하는 .map 파일을 생성합니다.\n\n\n--sourceRoot\nstring\n\n디버거가 소스 위치 대신 TypeScript 파일을 찾아야 하는 위치를 지정합니다. 설계 시점에 소스가 아닌 런타임에 소스가 있는 경우 이 옵션을 사용하세요. 지정한 위치는 소스 파일이 위치할 디버깅 위치를 지정하기 위해 소스 맵에 포함됩니다.\n\n\n--strict\nboolean\nfalse\n모든 엄격한 타입 검사 옵션을 활성화합니다. --strict를 활성화하면 --noImplicitAny, --noImplicitThis, --alwaysStrict, --strictNullChecks 및 --strictFunctionTypes이 가능합니다.\n\n\n--strictFunctionTypes\nboolean\nfalse\n함수 타입에 대한 bivariant 매개변수를 비활성화합니다.\n\n\n--strictNullChecks\nboolean\nfalse\nstrict null checking 모드에서는 null과 undefined 값이 모든 타입의 도메인에 있지 않고 그 자체와 any만 할당할 수  있습니다(한 가지 예외사항은 undefined 또한 void에 할당 가능하다는 것입니다).\n\n\n--stripInternal[1]\nboolean\nfalse\n/** @internal */ JSDoc 주석을 가진 코드에 대한 선언을 방출하지 않습니다.\n\n\n--suppressExcessPropertyErrors\nboolean\nfalse\n객체 리터럴에 대한 프로퍼티 초과 검사를 억제합니다.\n\n\n--suppressImplicitAnyIndexErrors\nboolean\nfalse\n인덱스 시그니처가 없는 객체를 인덱싱하는 경우 --noImplicitAny 억제합니다. 오류를 시그니처 자세한 내용은 #1232 이슈를 참조하세요.\n\n\n--target-t\nstring\n\"ES3\"\nECMAScript 대상 버전 지정: \"ES3\" (기본값), \"ES5\", \"ES6\"/\"ES2015\", \"ES2016\", \"ES2017\" 또는 \"ESNext\".  주의사항: \"ESNext\"는 최신 ES 제안 기능을 대상으로 합니다.\n\n\n--traceResolution\nboolean\nfalse\n모듈 해석 로그 메세지를 보고합니다.\n\n\n--types\nstring[]\n\n타입 정의가 포함될 이름의 목록. 자세한 내용은 @types, --typeRoots 및 --types를 참조하세요.\n\n\n--typeRoots\nstring[]\n\n타입 정의가 포함될 폴더의 목록. 자세한 내용은 @types, --typeRoots 및 --types를 참조하세요.\n\n\n--version-v\n\n\n컴파일러의 버전을 출력합니다.\n\n\n--watch-w\n\n\n컴파일러를 와치 모드로 실행합니다. 입력 파일을 와치하여 변경 시 다시 컴파일합니다.\n\n\n\n\n[1] 이 옵션은 실험단계입니다.\n[2] 이 옵션은 tsconfig.json에서만 허용되며 커맨드 라인에서는 허용되지 않습니다.\n\n관련사항\n\ntsconfig.json 파일에서 컴파일러 옵션 설정하기\nMSBuild projects 프로젝트에서 컴파일러 옵션 설정하기\n\n"},"pages/Compiler Options in MSBuild.html":{"url":"pages/Compiler Options in MSBuild.html","title":"MSBuild에서의 컴파일러 옵션","keywords":"","body":"개요\n컴파일러 옵션은 MSBuild 프로젝트 내의 MSBuild 속성을 사용하여 지정할 수 있습니다.\n예제\n  \n    false\n    true\n  \n  \n    true\n    false\n  \n  \n\n맵핑\n\n\n\n컴파일러 옵션\nMSBuild 속성 이름\n허용된 값\n\n\n\n\n--allowJs\nMSBuild에서 지원되지 않습니다\n\n\n\n--allowSyntheticDefaultImports\nTypeScriptAllowSyntheticDefaultImports\nboolean\n\n\n--allowUnreachableCode\nTypeScriptAllowUnreachableCode\nboolean\n\n\n--allowUnusedLabels\nTypeScriptAllowUnusedLabels\nboolean\n\n\n--alwaysStrict\nTypeScriptAlwaysStrict\nboolean\n\n\n--baseUrl\nTypeScriptBaseUrl\n파일 경로\n\n\n--charset\nTypeScriptCharset\n\n\n\n--declaration\nTypeScriptGeneratesDeclarations\nboolean\n\n\n--declarationDir\nTypeScriptDeclarationDir\n파일 경로\n\n\n--diagnostics\nMSBuild에서 지원되지 않습니다\n\n\n\n--disableSizeLimit\nMSBuild에서 지원되지 않습니다\n\n\n\n--emitBOM\nTypeScriptEmitBOM\nboolean\n\n\n--emitDecoratorMetadata\nTypeScriptEmitDecoratorMetadata\nboolean\n\n\n--experimentalAsyncFunctions\nTypeScriptExperimentalAsyncFunctions\nboolean\n\n\n--experimentalDecorators\nTypeScriptExperimentalDecorators\nboolean\n\n\n--forceConsistentCasingInFileNames\nTypeScriptForceConsistentCasingInFileNames\nboolean\n\n\n--help\nMSBuild에서 지원되지 않습니다\n\n\n\n--importHelpers\nTypeScriptImportHelpers\nboolean\n\n\n--inlineSourceMap\nTypeScriptInlineSourceMap\nboolean\n\n\n--inlineSources\nTypeScriptInlineSources\nboolean\n\n\n--init\nMSBuild에서 지원되지 않습니다\n\n\n\n--isolatedModules\nTypeScriptIsolatedModules\nboolean\n\n\n--jsx\nTypeScriptJSXEmit\nReact 또는 Preserve\n\n\n--jsxFactory\nTypeScriptJSXFactory\n제한된 이름\n\n\n--lib\nTypeScriptLib\n쉼표로 구분된 문자열 목록\n\n\n--listEmittedFiles\nMSBuild에서 지원되지 않습니다\n\n\n\n--listFiles\nMSBuild에서 지원되지 않습니다\n\n\n\n--locale\n자동\n자동으로 PreferredUILang 값 설정\n\n\n--mapRoot\nTypeScriptMapRoot\n파일 경로\n\n\n--maxNodeModuleJsDepth\nMSBuild에서 지원되지 않습니다\n\n\n\n--module\nTypeScriptModuleKind\nAMD, CommonJs, UMD, System or ES6\n\n\n--moduleResolution\nTypeScriptModuleResolution\nClassic 또는 Node\n\n\n--newLine\nTypeScriptNewLine\nCRLF 또는 LF\n\n\n--noEmit\nMSBuild에서 지원되지 않습니다\n\n\n\n--noEmitHelpers\nTypeScriptNoEmitHelpers\nboolean\n\n\n--noEmitOnError\nTypeScriptNoEmitOnError\nboolean\n\n\n--noFallthroughCasesInSwitch\nTypeScriptNoFallthroughCasesInSwitch\nboolean\n\n\n--noImplicitAny\nTypeScriptNoImplicitAny\nboolean\n\n\n--noImplicitReturns\nTypeScriptNoImplicitReturns\nboolean\n\n\n--noImplicitThis\nTypeScriptNoImplicitThis\nboolean\n\n\n--noImplicitUseStrict\nTypeScriptNoImplicitUseStrict\nboolean\n\n\n--noStrictGenericChecks\nTypeScriptNoStrictGenericChecks\nboolean\n\n\n--noUnusedLocals\nTypeScriptNoUnusedLocals\nboolean\n\n\n--noUnusedParameters\nTypeScriptNoUnusedParameters\nboolean\n\n\n--noLib\nTypeScriptNoLib\nboolean\n\n\n--noResolve\nTypeScriptNoResolve\nboolean\n\n\n--out\nTypeScriptOutFile\n파일 경로\n\n\n--outDir\nTypeScriptOutDir\n파일 경로\n\n\n--outFile\nTypeScriptOutFile\n파일 경로\n\n\n--paths\nMSBuild에서 지원되지 않습니다\n\n\n\n--preserveConstEnums\nTypeScriptPreserveConstEnums\nboolean\n\n\n--preserveSymlinks\nTypeScriptPreserveSymlinks\nboolean\n\n\n--listEmittedFiles\nMSBuild에서 지원되지 않습니다\n\n\n\n--pretty\nMSBuild에서 지원되지 않습니다\n\n\n\n--reactNamespace\nTypeScriptReactNamespace\nstring\n\n\n--removeComments\nTypeScriptRemoveComments\nboolean\n\n\n--rootDir\nTypeScriptRootDir\n파일 경로\n\n\n--rootDirs\nMSBuild에서 지원되지 않습니다\n\n\n\n--skipLibCheck\nTypeScriptSkipLibCheck\nboolean\n\n\n--skipDefaultLibCheck\nTypeScriptSkipDefaultLibCheck\nboolean\n\n\n--sourceMap\nTypeScriptSourceMap\n파일 경로\n\n\n--sourceRoot\nTypeScriptSourceRoot\n파일 경로\n\n\n--strict\nTypeScriptStrict\nboolean\n\n\n--strictFunctionTypes\nTypeScriptStrictFunctionTypes\nboolean\n\n\n--strictNullChecks\nTypeScriptStrictNullChecks\nboolean\n\n\n--stripInternal\nTypeScriptStripInternal\nboolean\n\n\n--suppressExcessPropertyErrors\nTypeScriptSuppressExcessPropertyErrors\nboolean\n\n\n--suppressImplicitAnyIndexErrors\nTypeScriptSuppressImplicitAnyIndexErrors\nboolean\n\n\n--target\nTypeScriptTarget\nES3, ES5, 또는 ES6\n\n\n--traceResolution\nMSBuild에서 지원되지 않습니다\n\n\n\n--types\nMSBuild에서 지원되지 않습니다\n\n\n\n--typeRoots\nMSBuild에서 지원되지 않습니다\n\n\n\n--watch\nMSBuild에서 지원되지 않습니다\n\n\n\nMSBuild 전용 옵션\nTypeScriptAdditionalFlags\n모든 컴파일러 옵션\n\n\n\n여러분의 Visual Studio 버전에서 지원되는 기능은 무엇일까요?\nC:\\Program Files (x86)\\MSBuild\\Microsoft\\VisualStudio\\v$(VisualStudioVersion)\\TypeScript\\Microsoft.TypeScript.targets 파일을 확인하세요.MSBuild XML 태그와 tsc 컴파일러 옵션 사이의 신뢰할 수 있는 맵핑이 여기에 있습니다.\nToolsVersion\n프로젝트 파일의 1.7 속성 값은 빌드하는 데 사용할 컴파일러 버전을 식별합니다 (이 예제에서는 1.7).이렇게 하면 프로젝트가 다른 컴퓨터에 있는 동일한 버전의 컴파일러에 대한 빌드를 허용합니다.\n만약 TypeScriptToolsVersion이 지정되지 않으면 설치된 최신 컴파일러 버전을 사용하여 빌드합니다.\n최신 버전의 TS를 사용하는 사용자에게는 첫 로드 시 프로젝트를 업그레이드하라는 메시지가 표시됩니다\nTypeScriptCompileBlocked\n다른 빌드 도구를 사용하여 프로젝트 (예: 걸프, 그런트 등) 그리고 개발을 위한 VS와 디버깅 환경을 사용하는 경우 프로젝트에서 true를 설정하세요.\n이렇게 하면 모든 편집 지원이 제공되지만 F5키를 눌러도 빌드가 지원되지 않습니다.\n"},"pages/Integrating with Build Tools.html":{"url":"pages/Integrating with Build Tools.html","title":"빌드 도구와 통합","keywords":"","body":"빌드 도구들\n\nBrowserify\nDuo\nGrunt\nGulp\nJspm\nWebpack\nMSBuild\nNuGet\n\nBrowserify\n설치\nnpm install tsify\n\n커맨드 라인 인터페이스 사용\nbrowserify main.ts -p [ tsify --noImplicitAny ] > bundle.js\n\nAPI 사용\nvar browserify = require(\"browserify\");\nvar tsify = require(\"tsify\");\n\nbrowserify()\n    .add(\"main.ts\")\n    .plugin(\"tsify\", { noImplicitAny: true })\n    .bundle()\n    .pipe(process.stdout);\n\n자세한 내용: smrq/tsify\nDuo\n설치\nnpm install duo-typescript\n\n커맨드 라인 인터페이스 사용\nduo --use duo-typescript entry.ts\n\nAPI 사용\nvar Duo = require(\"duo\");\nvar fs = require(\"fs\")\nvar path = require(\"path\")\nvar typescript = require(\"duo-typescript\");\n\nvar out = path.join(__dirname, \"output.js\")\n\nDuo(__dirname)\n    .entry(\"entry.ts\")\n    .use(typescript())\n    .run(function (err, results) {\n        if (err) throw err;\n        // 컴파일된 결과를 출력 파일에 작성합니다.\n        fs.writeFileSync(out, results.code);\n    });\n\n자세한 내용: frankwallis/duo-typescript\nGrunt\n설치\nnpm install grunt-ts\n\n기본 Gruntfile.js\nmodule.exports = function(grunt) {\n    grunt.initConfig({\n        ts: {\n            default : {\n                src: [\"**/*.ts\", \"!node_modules/**/*.ts\"]\n            }\n        }\n    });\n    grunt.loadNpmTasks(\"grunt-ts\");\n    grunt.registerTask(\"default\", [\"ts\"]);\n};\n\n자세한 내용: TypeStrong/grunt-ts\nGulp\n설치\nnpm install gulp-typescript\n\nBasic gulpfile.js\nvar gulp = require(\"gulp\");\nvar ts = require(\"gulp-typescript\");\n\ngulp.task(\"default\", function () {\n    var tsResult = gulp.src(\"src/*.ts\")\n        .pipe(ts({\n              noImplicitAny: true,\n              out: \"output.js\"\n        }));\n    return tsResult.js.pipe(gulp.dest(\"built/local\"));\n});\n\n자세한 내용: ivogabe/gulp-typescript\nJspm\n설치\nnpm install -g jspm@beta\n\n주의사항: 현재 jspm의 TypeScript 지원은 0.16beta 입니다.\n자세한 내용: TypeScriptSamples/jspm\nWebpack\n설치\nnpm install ts-loader --save-dev\n\n기본 webpack.config.js\nmodule.exports = {\n    entry: \"./src/index.tsx\",\n    output: {\n        filename: \"bundle.js\"\n    },\n    resolve: {\n        // '.ts'와 '.tsx'를 해석 가능한 확장자로 추가합니다.\n        extensions: [\"\", \".webpack.js\", \".web.js\", \".ts\", \".tsx\", \".js\"]\n    },\n    module: {\n        loaders: [\n            // '.ts' 또는 '.tsx' 확장자를 가진 모든 파일은 'ts-loader'에 의해 처리됩니다.\n            { test: /\\.tsx?$/, loader: \"ts-loader\" }\n        ]\n    }\n}\n\nts-loader에 대한 자세한 내용은 여기를 참조하세요.\n대안:\n\nawesome-typescript-loader\n\nMSBuild\n프로젝트 파일을 업데이트하여 로컬에 설치된 Microsoft.TypeScript.Default.props (맨 위)와 Microsoft.TypeScript.targets (맨 아래) 파일을 포함하도록 하세요:\n\n\n  \n  \n\n  \n  \n    false\n    true\n  \n  \n    true\n    false\n  \n\n  \n  \n\n\nMSBuild 컴파일러 옵션 정의에 대한 자세한 내용: MSBuild 프로젝트의 컴파일러 옵션 설정\nNuGet\n\n우-클릭 -> Manage NuGet Packages\nMicrosoft.TypeScript.MSBuild를 검색하세요\nInstall 클릭\n설치가 완료되면 다시 빌드 하세요!\n\n자세한 내용은 패키지 매니저 다이얼로그와 NuGet과 nightly builds 사용\n"},"pages/Nightly Builds.html":{"url":"pages/Nightly Builds.html","title":"Nightly 빌드","keywords":"","body":"TypeScript의 master 브랜치의 nightly 빌드는 PST midnight까지 NPM과 NuGet에 배포됩니다.다음과 같이 도구를 사용하여 가져올 수 있습니다.\nnpm 사용\nnpm install -g typescript@next\n\nMSBuild에 NuGet 사용\n\n주의사항: NuGet 패키지를 사용하도록 프로젝트를 구성해야 합니다. 자세한 내용은 NuGet를 사용하도록 MSBuild 프로젝트 구성을 참조하십시오.\n\nnightlies는 www.myget.org에서 이용 가능합니다.\nThere are two packages:\n\nMicrosoft.TypeScript.Compiler: 도구만 (tsc.exe, lib.d.ts, 등.) .\nMicrosoft.TypeScript.MSBuild: 위와 같은 도구뿐만 아니라 MSBuild 작업 및 대상 (Microsoft.TypeScript.targets, Microsoft.TypeScript.Default.props, 등.)\n\nnightly 빌드를 사용하도록 IDE 업데이트\nnightly drop을 사용하도록 IDE를 업데이트할 수도 있습니다.먼저 npm을 통해 패키지를 설치해야 합니다.npm 패키지를 전역으로 설치하거나 로컬 node_modules 폴더에 설치할 수 있습니다.\n이 섹션의 나머지 부분에서는 typescript@next가 이미 설치되어 있다고 가정합니다.\nVisual Studio Code\n.vscode/settings.json 파일을 다음과 같이 업데이트하세요:\n\"typescript.tsdk\": \"/node_modules/typescript/lib\"\n\n자세한 내용은 VSCode 문서를 참조하세요.\nSublime Text\nSettings - User 파일을 다음과 같이 업데이트하세요:\n\"typescript_tsdk\": \"/node_modules/typescript/lib\"\n\n자세한 내용은 Sublime Text를 위한 TypeScript 플러그인 설치 문서를 참조하세요.\nVisual Studio 2013 및 2015\n\n주의사항: 대부분의 변경 사항에는 새로운 버전의 VS TypeScript 플러그인을 설치할 필요는 없습니다.\n\n현재 nightly build에는 전체 플러그인 설정이 포함되어 있지 않지만 nightly 기반으로 설치 프로그램을 배포하기 위해 노력하고 있습니다.\n\nVSDevMode.ps1 스크립트 다운로드.\n\n또한 커스텀 언어 서비스 파일 사용에 대한 위키 페이지를 참조하세요.\n\n\nPowerShell 커맨드 라인 창에서 다음을 실행합니다:\nVS 2015:\nVSDevMode.ps1 14 -tsScript /node_modules/typescript/lib\n\nVS 2013:\nVSDevMode.ps1 12 -tsScript /node_modules/typescript/lib\n\n\n\nIntelliJ IDEA (Mac)\nPreferences > Languages & Frameworks > TypeScript를 선택합니다:\n\nTypeScript 버전: npm과 함께 설치한 경우: /usr/local/lib/node_modules/typescript/lib\n\n"}}}
\ No newline at end of file
+{"index":{"version":"0.5.12","fields":[{"name":"title","boost":10},{"name":"keywords","boost":15},{"name":"body","boost":1}],"ref":"url","documentStore":{"store":{"./":["contributing.md를","handbook","handbook을","typescript","가능하며","감사하겠습니다.","규칙과","그","누구나","다양한","등록","문서","및","밖에도","방법은","번역","번역,","번역가이드","번역하는","상황","상황은","소개","수","언제나","오타,","요청은","의견","이곳을","이슈에","있습니다.","잘못된","주세요.","진행","참고해","참여","참여하기","참여하는","통해","프로젝트입니다.","피드백은","한글","해주시면","확인할","환영합니다:)"],"pages/tutorials/TypeScript in 5 minutes.html":["\"","\"hello,","\"jane","\"jane\",","\"m.\",","\"user\"","\"user\");","'number[]'","'person'","'string'.","(build","(classes)","(compil","(instal","(interfaces)","(node.j","(run","(type","+",".t","1,","2015","2017과","2];","3는","5분",":","=",">","[0,","annotations)","app)","argument","assign","class","code)","constructor(publ","document.body.textcont","dom","error","f12","file)","first","firstnam","firstname:","fullname:","function","g","greeter","greeter(person)","greeter(person:","greeter(user);","greeter.html에","greeter.html을","greeter.j","greeter.js를","greeter.t","greeter.ts를","implement","instal","interfac","javascript","javascript로","javascript에서","javascript의","lastnam","lastname:","lastname;","middleiniti","middleinitial:","new","npm","npm을","oo의","paramet","person","person)","person.firstnam","person.lastname;","person;","playground에","public","public을","return","sampl","string","string)","string,","string;","student","student(\"jane\",","studio","studio과","studio에서","this.fullnam","ts2345:","tsc","type","typescript","typescript)","typescript가","typescript는","typescript로","typescript를","typescript에서,","typescript와","typescript의","updat","user","user\";","visual","web","{","}","};","가지","가지가","간단한","갖고","같은","같이","개수의","객체","객체를","것만으로도","것은","것을","것이라는","것입니다.","결과는","결정할","경고를","경우","경우,","경우:","경우에","계약을","관련된","구조가","구조와","구현할","규모에서","그","그래서","그러나","기능을","기록하는","기반","기반한","기반해서","기본적으로","기존의","나타내는","내부","넣을","눌러","다시","다운로드할","다음과","다음의","단일","단지","당신이","더","도구와","도움말을","동일하다는","동일한","될","됩니다.","두","따라","또한,","라인에서","리팩토링을","마우스","마우스를","마지막","마지막으로,","마찬가지로,","만들겠습니다.","만들기","만들어","만약","많은","매개변수","매개변수로","매개변수와","매니저)","명시적인","몇","모두,","모든","목록과","못한","문자열","및","바꿀","바로","발생한","발전시켜","방법에는","방법입니다.","배열을","버튼으로","번째","변경해","변수의","보겠습니다.","보는","보려면,","복사하세요.","복사하여","볼","분석을","붙여","브라우저에서","뿐입니다.","사용되는","사용자의","사용하는","사용하여","사용할","사용합니다.","사용해","사용했지만,","새로운","생성되었습니다.","생성된","생성자와","생성자의","생성하는","서로","설치","설치하기","설치하는","설치하지","섹션을","수","수준을","시","시작했습니다!","식별자","실행하기","실행하세요:","실행해보세요!","심벌을","아래의","아직","안에","않았다면","않을","알","알려줄","애플리케이션","애플리케이션을","앱","앱에서","앱을","없이,","에디터에서,","여기서는","열거나,","열어","예상대로","예상치","예시를","예제를","오류가","오른쪽","올려놓고,","올려놓으면","올바른","옵션:","완료","요구하는","요소","우리는","웹","웹사이트의","위에","유의하세요.","의도된","이","이곳에서","이동할","이름으로","이름을","이용한","이용할","이전의","이제","인수를","인수에","인수의","인터페이스","인터페이스가","인터페이스를","일반","입력하고,","입력하세요:","있게","있는","있습니다.","있습니다:","자동으로","자주","작동하는","작동하여,","작동하지","작동합니다.","작성하세요:","잘","재실행하면","전달하도록","절","점을","정보는","정의로","정적","제거해보세요.","제공된","제공하는","제공합니다.","존재하기는","존재하더라도","주목하세요.","지원과","지원합니다.","지향","참고하세요.","참조","첫","추가하세요.","추론되기도","추상화","축약형일","축약형입니다.","커맨드","커서를","컴파일러를","컴파일하기","컴파일하면,","코드","코드가","코드는","코드를","코드에","코드와","코드의","코드입니다.","크게","클래스","클래스는","클래스를","클래스와","클릭하고","키를","타입","타입에","타입은","타입을","타입이","파일","파일에","파일은","파일이","패키지","포함하고","표기","표기는","표기를","표기에","프로그래머가","프로그래밍","프로토타입","프로퍼티를","플러그인","필드를","하게","하지만,","한다는","함께","함수","함수나","함수를","함수의","합니다.","해당","해준다는","행을","형태를","호출","호출에서","호출하려고","호출했다는","호환","호환되는","확인하세요.","확장자를","확장해"],"pages/tutorials/ASP.NET Core.html":["\"./app\";","\"./app.ts\"","\"./app.ts\",","\"./main.ts\"","\"./model\"","\"./model.ts\",","\"./model.ts\"를","\"0.1.2\",","\"0.19.24\",","\"1.0.0","\"2.0.0","\"2.2.0\"","\"3.9.0\",","\"5.0.0","\"^0.6.4\",","\"angular2\":","\"angular2/core\"","\"angular2/platform/browser\";","\"compileonsave\":","\"compileroptions\"","\"compileroptions\":","\"compileroptions\"에","\"del\":","\"del\"을","\"dependencies\":","\"dependencies\"에","\"devdependencies\":","\"dom\"","\"dom\"]을","\"emitdecoratormetadata\":","\"es2015\",","\"es5\"","\"es5\",","\"excludes\"에","\"experimentaldecorators\":","\"files\"","\"files\":","\"files\"에","\"gulp\":","\"gulp\"와","\"hello","\"host","\"lib\":","\"loading...\"","\"microsoft.aspnet.iisplatformhandler\":","\"microsoft.aspnet.server.kestrel\":","\"microsoft.aspnet.staticfiles\":","\"noemitonerror\":","\"noimplicitany\":","\"nomaplicitany\"가","\"reflect","\"rxjs\":","\"sourcemap\":","\"systemjs\":","\"target\":","\"typescript\";","\"zone.js\":","${compiler}","${framework}!`;","'cjs',","'clean'작업도","'clean'작업이","'default'로","'js'","'node_modules/angular2/bundles/angular2","'node_modules/rxjs/bundles/rx.js']","'node_modules/systemjs/dist/system.src.js',","'scripts':","'scripts/**/*.map'],","'scripts/**/*.ts',","'안에","()","(.net","(add","(configur","(creat","(ctrl","(debug)","(document.getelementbyid(\"compiler\")","(document.getelementbyid(\"framework\")","(instal","(set","(test)","(updat","(write","*/","+","/*","///","1.1","1.1.2:","2","2)","2017이","2와","2의","5",":","=",">","@component({","[","[\"es2015\",","['lib'],","['node_modules/angular2/bundles/angular2.js',","['scripts/**/*.js',","]","],","`hello","`mi","angular","angular가","app","app)","app.ts에","app.ts의","app.usedefaultfiles();","app.useiisplatformhandler();","app.usestaticfiles();","app`,","applic","asp.net","beta.11\",","beta.2\",","bootstrap(myapp);","breakpoint가","breakpoint를","browse.","build)","c#","class","cloud\"","code)","compil","compiler)","compiler:","configur","configurationfile을","configure(iapplicationbuild","configure를","console.error.bind(console));","const","core","core)","core를","debugg","default","defaultextension:","del","del(['wwwroot/scripts/**/*']);","depend","dependencies)","dependencies에","devdepend","div가","edge에서","empti","empty를","entri","es2015에","es2015에서","exampl","explorer가","explorer를","export","f12","file","file을","final\"","final\",","format:","framework","framework:","function","getcompiler()","gulp","gulp)","gulp.src(paths.libs).pipe(gulp.dest('wwwroot/scripts/lib'));","gulp.src(paths.scripts).pipe(gulp.dest('wwwroot/scripts'))","gulp.src(paths.scripts).pipe(gulp.dest('wwwroot/scripts'));","gulp.task('clean',","gulp.task('default',","gulp.task('lib',","gulpfile.js라는","gulpfile.js를","gulpfile.js은","gulpfile을","gulp의","html","htmlinputelement).value;","http://go.microsoft.com/fwlink/?linkid=518007","import","index.html에","index.html의","index.html이라는","item을","javascript","javascript파일을","js를","lib","libs:","lib에","loading...","localhost","main.ts라는","manag","metadata\":","microsoft.aspnetcore.staticfil","model","model.ts라는","myapp","mymodel","mymodel();","n)","new","npm","npm)","npm3에서","npm을","nuget","open","packag","package.json을","package.json의","packages:","packages를","page)","path","peer","point입니다.","polyfills.js',","project)","project.json에서","promise과","public","rc1","require('del');","require('gulp');","restor","return","runner","sayhello()","scripts/app.ts를","scripts:","scripts라고","scripts를","scripts에","selector:","server)","shift","simpl","startup.cs에서","studio는","studio에","studio에게","system.config({","system.import('scripts/main').then(null,","systemjs를","task","template:","this.model.compiler;","true","true,","true를","tsconfig.json","tsconfig.json)","tsconfig.json를","tsconfig.json을","type","typescript","typescript\"","typescript)","typescript가","typescript를","typescript에","typescript의","up","usedefaultfiles와","usestaticfil","var","visual","visualstudio2015","visualstudio에","void","vs2015","vs2015의","vs2017","vs2017의","vs를","web","wwwroot","wwwroot에","{","{bootstrap}","{component}","{myapp}","{mymodel}","{{getcompiler()}}`","}","})","});","},","};","—","가이드를","가져오려면","간단한","같습니다:","같아야","같은","같이","검사가","검색","것들에는","것은","것이므로","것입니다","것입니다.","경로.","경우","경우는","경우에는","교체합니다.","그","그냥","그러면","그런","그리고","기본","기본값과","기본이","기본적인","끝난","나열합니다.","나열해야","내용을","누르고","다른","다시","다운로드할","다음","다음과","다음으로","단계는","대신","대체하세요:","대한","데코레이터가","데코레이터에","될","들어가고","디버그","때","때마다","때문에","또","또는","라이브러리","라인에","라인이","로드됩니다.asp.net","로컬에서","를","리스트","리스트를","마우스","마지막으로","만들","만들기","먼저","메시지가","명시적으로","및","방법을","버튼으로","번째","변경하십시오","보게해야","보려면","보일","복사해야","부르겠습니다.","빌드","빌드가","빌드를","빌드에","빌드의","빨간선이","사라지려면","사용","사용되지","사용하기","사용하십시오.","사용합니다","사항은","상자에","새","새로고침","새로운","서버","선언을","선택","선택을","선택하고","선택하세요.","설정","설정은","설정합니다","설정합니다.","설정해야","설치","설치되었으므로","설치를","설치할","설치합니다.이","섹션에","손쉽게","수","수도","스타트","시작해야","실수로","실행","실행됩니다.","실행하고","실행하기","실행하도록","실행하면","실행하십시오.","실험적","쓰지","아래의","아직","안에","않고","않도록","않으면","않으므로","않은","않을","알려줘야","알아야","애플리케이션","애플리케이션을","앱에서","앱을","앱이","앵귤러","업데이트","업데이트된","업데이트할","없는","에","여기를","연결(pipe)","예제","오른쪽","올바르게","요청하면","웹","위한","위해","위해서는","유사합니다.","의존성","의존성으로","의존성은","의존성을","의존성이","의존하지","이","이것뿐입니다.다음으로","이라고","이러한","이를","이름","이름을","이름의","이름인","이제","일부로","입력","입력하고","입력하십시오","입력할","입력합니다.","있는","있도록","있습니다","있습니다.","있습니다.\"compileonsave\"는","있을","있음)을","자세한","작동하는지","작성","작성할","작성합니다.","작업을","저장하는","저장한","정리하도록","정의하고","제외하고","좋습니다","준다.","줄은","중인","즉시","지시합니다.또한","지원이","지정되지","지정합니다.","직접","차이점을","찾습니다.","찾은","첫","최신","추가","추가하는","추가하십시오","추가하십시오.","추가하십시오.그런","추가하여","추가할","추가합니다","추가합니다.","추가해야","취소합니다.","컴파일러","코드","코드를","코드에","코어","퀵","클릭하고","클릭하십시오.","클릭하십시오.'default'","클릭하십시오.그런","클릭합니다.그런","키를","타입스크립트","타입이","탐색기를","태스크를","태스크에","탭을","테스트","파일","파일에","파일은","파일을","파일이","패키지를","페이지","포함시키기","폴더를","표시되지","표시된","표시됩니다","표시됩니다.","프로젝트","프로젝트를","프로젝트에","플러그인을","필요하지","필요한","필요합니다.","필요합니다.또한","하십시오.","한번","할","합니다","합니다.","합니다.script","합니다.tsconfig는","합니다.그렇지","합니다.프로젝트를","합니다.향후에는","항목을","해","확인합니다.","후에","후에는"],"pages/tutorials/Gulp.html":["\"./greet\";","\"compileroptions\":","\"es2015\"","\"es5\"","\"files\":","\"hello","\"noimplicitany\":","\"src/greet.ts\"","\"src/main.ts\"","\"src/main.ts\",","\"target\":","\"typescript\");","${compiler}`);","${name}`;","'.',","'copi","'default'","'default'...","()","(0.02","(0.05","(0.13","(1)과","(2)는","(add","(creat","(initi","(instal","(minim","(test","(unix","(write","...","./dist/main.js를",".bundle()",".es,",".es6",".js,",".js.pipe(gulp.dest(\"dist\"));",".jsx",".pipe(buffer())",".pipe(gulp.dest(\"dist\"));",".pipe(gulp.dest('dist'));",".pipe(source('bundle.js'))",".pipe(sourcemaps.init({loadmaps:",".pipe(sourcemaps.write('./'))",".pipe(tsproject())",".pipe(uglify())",".plugin(tsify)",".t",".transform('babelify',","1.36","2261","26","2808","2824",":","=","[","[\"copi","['.ts']","['copyhtml'],","['es2015'],","['src/*.html']","['src/main.ts'],","[10:34:20]","[10:34:21]","[10:35:22]","[10:35:24]","],","`hello","app)","babel","babel,","babelifi","babelify는","babelify도","babelify를","babelify에","babel은","babel의","basedir:","browserifi","browserify({","browserify,","browserify가","browserify를","browserify에","browserify의","buffer","buffer');","buffer와","bundl","bundle()","bundle);","bundle);을","bundle.js가","bundle.js의","bundle을","byte","cache:","cat","cd","cli","cli를","code)","commonj","commonjs를","console.log(`hello","console.log(sayhello(\"typescript\"));","const","copi","core","debug","debug:","default","default를","default의","dependencies)","dev","dist","dist/","dist/bundle.j","dist/index.html을","dist/main.j","dist에서","document.getelementbyid(divname);","elt","elt.innertext","entries:","es2015","es2015도","es3으로","es5","es5를","example)","export","extensions:","finish","function","g","greet.ts를","greet.ts에서","gulp","gulp.src(paths.pages)","gulp.task(\"copi","gulp.task(\"default\",","gulp.task('copyhtml',","gulp.task('default',","gulpfil","gulpfile.j","gulpfile.js)","gulpfile을","gulp로","gulp를","gulp에서","gulp을","gutil","gutil.log);","gutil.log);을","hello","hello(\"typescript\");","hello(compiler:","html","html\",","html\"],","html'","html'...","html이","import","index.html","init","instal","install을","javascript","load","main.t","main.ts를","mkdir","modul","module을","ms","name:","node","node.js는","node가","npm","option","packagecache:","page)","pages:","paragraph","path","point를","preset","presets:","preset을","proj","proj$","proj/","project)","proj라고","proj이라는","require(\"browserify\");","require(\"gulp","require(\"gulp\");","require(\"tsify\");","require(\"watchify\");","require('browserify');","require('gulp","require('gulp');","require('tsify');","require('vinyl","result","return","s","save","sayhello","sayhello(name);","sayhello(name:","sayhello를","seconds)","showhello","showhello(\"greeting\",","showhello(divname:","showhello에","simpl","sourc","source(vinil","sourcemap","sourcemaps');","sourcemaps도","sourcemaps에","sourcemaps이","src","src/","src/greet.t","src/greet.ts를","src/main.ts의","src에","start","stream","stream');","stream에","stream을","string)","string,","sudo를","true,","true}))","true를","ts","ts.createproject(\"tsconfig.json\");","tsconfig.json","tsconfig.json에","tsconfig.json을","tsifi","tsify는","tsproject","tsproject.src()","typeifi","typescript","typescript!\"를","typescript\");","typescript\"가","typescript,","typescript는","typescript를","typescript에서","typescript와","typescript의","typescript처럼","uglifi","uglify');","uglify는","uglify를","us","util","util\");","var","vinyl","vinyl으로","watchedbrowserifi","watchedbrowserify.on(\"log\",","watchedbrowserify.on(\"update\",","watchifi","watchify(browserify({","watchify,","watchify가","watchify로","watchify를","watchify에","world","world!","written","{","{}","{},","}","})","}).plugin(tsify));","});","};","~/src/proj/gulpfile.j","—","└─","├─","가","가이드는","가정합니다.","가져오도록","가지","간단한","감싸고","같은","같이","개발자","객체를","객체에","걸프","것에","것은","것을","것이므로","것입니다.","것입니다.entri","것입니다.즉","결과를","경우","계속","고침","골격으로","광범위한","구문을","구조입니다.","구조화해야","그","그런","글로벌","기능에","기능을","기본값을","기본적으로","끝납니다.","난독화로","내보내는","내보냅니다.소스","내에서","넣으면","노드에서","다시","다양한","다운로드","다음","다음과","당장은","대로","대상","대신","대한","데","돌아가서","동일한","될","둘","디렉토리부터","디버거를","디버깅","디버깅하는","디버깅할","때","때마다","때문에","또는","또한","라인에","로그했습니다.","로깅을","루트에","리팩토링해야합니다.","마지막으로","만들고","만들기","만듭니다","맞춤형","매우","맵","맵을","맵이","먼저","명령","모두","모듈","모듈을","모듈이","모든","묶어서","믹스에","및","바꿀","받게","방법을","방식으로","방출했습니다.이","백그라운드","번들","번들로","번들링","변경","변경되지","변경될","변경하고","변경하십시오","변경하여","변경할","변경합니다","변경합니다.이제","변경했습니다.편리하게도","변환을","변환하는","변환할","별도의","별칭)를","보겠습니다.","보겠습니다.이것은","붙여야","붙이겠지만","브라우저로","브라우저에서","브레이크포인트가","브레이크포인트을","빌드에","빌드한","사용하겠지만","사용하고","사용하기","사용하는","사용하면","사용하여","사용한","사용할","사용합니다.package.json","사용했지만","사이클을","사항이","사항이지만","새로","새로고침","새로운","생성","생성합니다","생성합니다.","선택","설정을","설정이","설정하여","설치","설치하십시오","설치하십시오.gulp","설치하십시오.tsify는","설치하십시오.uglify의","설치하십시오.uglify처럼","설치할","설치해야","세","소스","소스맵을","수","수도","수정합시다","쉬운","스크립트에","스타트","시간을","시스템을","시작하겠습니다","시작하기","시작하려면","시작하여","시작합시다.","시작해야","실제","실행되고","실행되어야","실행될","실행됩니다.main.ts에서","실행하고","실행하도록","실행하며","실행하면","안에","않는","않은","알려줍니다.","알림을","압축되는지","압축하기","압축합니다.","앞에","앱","앱에서","약간","언제든","업데이트하십시오","엉망으로","여기에는","열고","열어","예제","옵션으로","요점은","원본","원하는","위한","위해","유사해야","유연한","유용합니다.","유지하려면","유지했습니다.","의미합니다.","의미합니다.watchify와","의미합니다.또한","의존성","의존성에","의존성으로","이","이것을","이동하겠습니다.이를","이를","이름을","이미","이상을","이전과","이제","이제는","인","인라인","인쇄해야합니다.","인스턴스를","인식하는","인해","일련의","일시","일입니다.더","있는","있다고","있다는","있도록","있습니다","있습니다).","있습니다.","있습니다.먼저","있습니다.브라우저의","있습니다.이제","있습니다.페이지를","있으며","있지만","자체에는","작동하는지","작성","작성해","작업에서","작은","저장","저장하십시오.","저장할","전달할","전송되는","전에","전용","점차적으로","접근할","정확히","제공된","제외하고는","존재합니다.이러한","좋은","주목하십시오.이로","주어야","줄이도록","중","중지하고","지원하지","지정한","지정합니다.","진행할","처리하므로","초기화","추가","추가하고","추가하는","추가하십시오","추가할","추가합니다.default가","추가합니다.npm과","추가해","추가해야","출력","출력과","출력은","출력을","출력이","컴파일러를","컴파일러에","컴파일러입니다.따라서","컴파일을","컴파일합니다.이를","코드를","코드에","코드에서","콘솔에","퀵","태스크를","테스트","테스트하십시오.페이지에","테스트하여","테스트할","텍스트를","통해","튜토리얼에서는","파이프","파일","파일로","파일만","파일은","파일을","패키지로","패키지를","페이지","페이지를","편집","폴더를","폴더에서","표시되어야","프로그램에서","프로그램을","프로젝트","프로젝트를","프로젝트의","플러그인으로","플러그인을","플러그인입니다.","플러그인입니다.vinyl","필요합니다.babel은","필요합니다.기본적으로","하고","하고자","하기","하나가","하나의","하는","한다는","할","함께","함수를","함수에","합니다","합니다.","합니다.(3)을","합니다.다행히도","합니다:","해야","했습니다.","했으므로","형식으로","호출만","호출에서","호출은","호출을","호출하도록","호출하여","호출한","호출해야","확인하기","확인하십시오","확장자가","확장자를","후"],"pages/tutorials/Migrating from JavaScript.html":["!array.isarray(arguments[1]))","!를","\"./built\",","\"./dist/bundle.js\",","\"./src/**/*\"","\"./src/index.ts\",","\".js\"]","\".ts\",","\".tsx\",","\".web.js\",","\".webpack.js\",","\"allowjs\":","\"awesom","\"compileroptions\":","\"es5\"","\"include\":","\"outdir\":","\"red\",","\"red\";","\"sourc","\"target\":","&","&&","'.js'","'.ts'","'.tsx'","'.tsx'를","'awesom","'define'.","'foo!'에","'foo'.과","'foo'는","'null'일","'require'.와","'sourc","'string[]'타입이","(allowj","(any,","(arguments.length","(earli","(export","(get","(import","(includ","(integr","(move","(no","(number를","(outdir와","(sequenti","(set","(strict","(target","(too","(weed","(write","(x:","(또는","**","+","...","...nums:",".j",".tsx로",".ts로","/","//","/\\.js$/,","/\\.tsx?$/,","/undefined라고","0,","0});","1,","11","11;","2","2);","2,","3,","4);","4]);","5",":","=","==","=>","@types/lodash","[","[\"\",","[1,","]","],","ad","allowunreachablecode와","allowunusedlabels로","amd","any)","any;","any[]):","any가","any는","any를","any와","app","argument","arguments)","arguments[0];","arguments[1];","arr","assertion)을","awesom","babelifi","babel과","benefits)","break문을","browserify와","build","built","builtd에","case","check","checks)","class","code나","color:","color에","commonjs가","configur","console.log(x)","constructor(publ","convers","declar","define(...args:","define([\"foo\"],","devtool:","directories)","dist","distancefromorigin(point:","dx","dy","ecmascript","entry:","errors)","export","express","express();","extensions:","f","feedpets(pets)","few","file)","file1.j","file2.j","filename:","files)","find","foo","foo!.length;","foo()","foo.dostuff();","foo.length;","foo:","foo;","function","function(foo)","function(pets)","function(point:","function(this:","get","getdistance(p:","getdistance의","guide를","gulp","gulp를","implicit","import","import에","instal","interfac","javascript","javascript가","javascript로","javascript에서","javascript와","jsx를","lib","loader","loader\"","loader'로","loader'에","loader:","loaders:","loader도","loader를","loader와","lodash를","lodash와","many/too","map","map\",","math.sqrt(dx","modul","module.export","module.exports.feedpet","module.exports와","module:","moduleresolut","modules)","mycoolfunction()","mycoolfunction(f:","mycoolfunction(function(x)","mycoolfunction가","mycoolfunction에","mycoolfunction이","name","no!","node/commonj","node/commonjs를","node로","noemitonerror","nofallthroughcasesinswitch는","noimplicitani","noimplicitany를","noimplicitreturns는","noimplicitthi","npm","null","null;","null과","null로","number","number(이)거나","number)","number;","number[]):","number의","nums:","object","object,","object가","object보다","object와","option","options.color","options.volum","options;","options에","options의","out","output:","p.i","p.x","point","point)","point):","point,","point.prototype.distancefromorigin","point:","preloaders:","pretty를","projectroot","properties)","public","react","require(\"express\");","require(\"foo\");","require(path:","requirej","requirejs/amd를","resolve:","return","s","sourc","src","src에","src와","src의","stricter","strictnullcheck","strictnullchecks가","strictnullchecks도","strictnullchecks를","string):","string;","string[]","studio","switch블록","test","test:","tests에","this)","this.getdistance({","this.x;","this.y;","this를","this의","tolowercase()와","tools)","true,","ts","tsc","tsconfig.json","tsconfig.json와","tsconfig.json이라는","tsc를","ts로","typescript","typescript가","typescript는","typescript로","typescript를","typescript에","typescript에서","typescript에서는","typescript의","uglify와","umd입니다.","undefin","undefined는","undefined이","union","up","var","visual","void,","void;","volume:","volume과","webpack","webpack.config.j","webpack에","webpack을","webpack의","word와","x,","x:","y)","y:","{","{}","{})","{};","{}가","{}로","{}를","{}을","|","}","})","},","};","│","└──","├──","가능성이","가능한","가장","가정할","가정합니다.","가정합니다.즉","가져","가져오기","가져올","가지","가지고","가지를","가진","가질","가집니다.","각","각각의","간단한","간단합니다.","값에","값을","갖는)","갖습니다.","갖지","갖춰야","같은","같이","같지만","개의","객체","객체를","걱정을","검사","검사는","검사를","검사의","것과","것들을","것으로","것은","것을","것이","것이고","것이든","것인지를","것입니다.","것입니다.각","것입니다.다행히도","것입니다.대신","것입니다.이는","것입니다.종종","것입니다.첫","것입니다.파일이","것입니다:","것처럼","결정하는","결정할","결합하여","경고가","경고를","경고합니다.이","경우","경우:","경우가","경우에는","계획이라면","곳에서","공백","관대하기","관리합니다.프로젝트에","관한","구문을","구성하고","구조가","구조로","그","그냥","그러면","그런","그레이션에는","그리고","기록하도록","기본적으로","기본적인","기술적으로","꽤","끝냈나요?","끝에","나","나머지","나은","나타날","나타납니다.","내","내보내기","내보내기는","내보낸","너무","너무나","높습니다.","높일","누릴","느껴질","느슨하면","다루기","다루는","다르게","다르지만","다른","다소","다시","다음","다음과","다음의","다할","단계가","단계는","단계를","단언(type","대로","대부분의","대신","대체로","대한","대해","대해서도","더","덜어주기","덮어쓰기도","덮어쓰지","도구","도구는","도구를","도구와","도구의","도달","동안","동일한","동일해야","된","될","됩니다.","됩니다.js에서","됩니다:","두","두고","두번째는","둘의","뒤에","들어","디렉토리","디렉토리가","디렉토리에","디렉토리에의","디버깅","디버깅이","때","때가","때는","때때로","때로는","때문에","또는","뛰어난","라벨에","라벨은","라이브러리를","라인에","레벨","레이아웃과","레이아웃은","로더보다","로더인","루트에","리터럴","리터럴에","마이","마이그레이션","마찬가지입니다.여기에서.","만들기","만들어졌으며","만약","만큼","많거나","많은","말할","매개","매개변수(...nums)를","매개변수를","매우","맵을","맵이","먼저","메서드로","메서드를","메시지가","명령문을","명시적(또는","명시하려면","명확한","몇","모델링할","모듈","모듈로","모듈에서","모듈을","모든","모르는","목록을","못한","무언가를","묵시적인","문서를","문제는","문제를","문제없는","문제없이","물론","및","바꾸는","바꿔야","바로","밖에","밖에서","반환문을","받기","받을","발견할","발생으로","발생하기","발생하는","발생하지","발생할","발생합니다.","방법에","방법을","방법이지만","방식으로","방지합니다.","버그가","버그를","버그의","버그이지만","버리게","버전으로","벅차다고","번들링이나","번째","범위에","베이스를","변수를","변환","변환하는","변환하려는","변환한","변환합니다","변환합니다.","병합하십시오","보냅니다","보통","볼","분리해야","분석을","불평하는","비밀스러운","빌드","빨간","빨리","빼먹는","뻬먹지","뼈대를","사람들은","사용","사용)","사용되며","사용하고","사용하기","사용하기로","사용하는","사용하도록","사용하려는","사용하면","사용하여","사용한다면","사용할","사용합니다.","사이에","살펴보겠습니다.새로운","살펴보고","상태로","상황에서","생각하는","생각하여","생각하지","생각해야합니다.word에서","생성된","생성하겠습니다:","생성하고","생태계를","선언","선언된","선언을","선언했을","선호해야","설명할","설명해야","설정","설정되어","설정되었다고","설정을","설정하기","설정하는","설정하면","설정하여","설정합니다.","설정해야","성공적으로","소스","속성을","수","수도","수없는","수정하기","수행할","순차적으로","숫자여야","쉬운","쉬워","쉽습니다.typescript에서","스크립트가","시스템을","시작하는","시작하면","시작할","시점에서도","실제로","실행","실행하게","실행하고","실행하려고","실행하면)","실행할","실행해야","쓰는","쓰면","아닌","아닙니다.중요한","안전도","안전성과","안전성을","않기","않는","않다는","않도록","않습니다.javascript","않습니다.이","않습니다:","않을","알게됩니다:","알고","알려주어야","알리기","암시적인","앞서","어떠한","어떤","어떻게","어렵지","언급","언급한","얻을","엄격하게","엄격한","엄격함을","업데이트해야","없다고","없습니다.","없습니다.typescript에서","없으며","없이","여기서","여전히","연결했을","연산자","열면","열어보세요","염두에","예를","예상치","예술적으로","오기","오는","오늘날에는","오류","오류가","오류를","오버로드를","옮기면","옳다고","옵션들...","옵션으로","옵션은commonjs,amd,system","옵션을","완성과","완성을","완전히","요점을","원래","원천이기","원치","원하는","위에서","위치를","위한","위해","유연한","유용하지만","유용합니다.","유형의","을","의미에서","의미하지만","의미합니다.","의존성을","의해","이","이것들은","이것은","이것을","이동","이득은","이득이","이때","이러한","이런","이렇게","이름을","이미","이에","이와","이유로","이전","이전에는","이점을","이해함으로써","인쇄할","인수","인수가","인수를","인터페이스나","인터페이스를","인해","일","일반적이라는","일반적인","일부","일이","읽습니다","읽어볼","읽은","읽을","잃어","입력","입력으로","있게","있고","있는","있다.","있다고","있다면","있습니다","있습니다.","있습니다.microsoft","있습니다.typescript를","있습니다.v","있습니다.가능하면","있습니다.그런","있습니다.그렇기","있습니다.다소","있습니다.또한","있습니다.아마도","있습니다.여기서","있습니다.예를","있습니다.이","있습니다.이러한","있습니다.이런","있습니다.전형적으로","있습니다.하지만","있습니다:","있어야","있으며","있을","있음을","있지","있지만","자동","자리에","자주","자체로","자체에","작성하게","작성하기","작성하기에","작성하는","작성한","작성할","작성해보세요","작성했을","작업해야","잘","잡기","장기적","적다는","적은","전에","전형적으로","전환하기","점에","점에서","정의하고","제거하고","제공하기","제공하는","제공합니다.일단","조금","조작할","조절할","존재하지","존재합니다.javascript","좀","종류와","좋습니다.","좋습니다.(아래의","좋아요","좋았어!javascript에서","주의해야","준비가","줄을","줄이","중","중간","즉시","즐겁다는","지금","지금부터","지루하지만","지시하고","지원을","지원하는","지정합니다:","직접","집니다.","차이점에","참고로","참조).","참조하는","찾아냈기","처리된","처리됩니다.","처리할","철자가","첫","체크","초기의","최상위","최선을","최신","추가","추가되는","추가하고자","추가하는","추가합니다.","추가했습니다.","추론된)","추론하지","출력","출력에는","출력을","충분한","컴파일하는","코드","코드:","코드를","코드와","코드처럼","클래스","클래스를","키워드를","타이프","타입","타입에","타입으로","타입을","타입의","타입이","타입이기","타입이라고","타입이어야","타입인","타입입니다.","통합","통합됩니다.거기서","통합은","통해","튜토리얼에서","튜토리얼에서는","튜토리얼이","트랜스파일러를","특별합니다.즉","특정","특정한","틀리거나","파이프","파일","파일(declar","파일과","파일로","파일에","파일은","파일을","파일의","파일이","판결났다면","패키지에","패턴입니다:","편집기","편집기로","편집기에서","평범한","포함)","포함시킬","포함할","포함합니다.typescript를","폴더","폴더가","표시되는","표시됩니다.built에","표시할","프로그램의","프로젝트","프로젝트를","프로젝트에서","프로젝트의","프로퍼티","프로퍼티도","프로퍼티를","플래그를","하나씩","하나의","하는","하면","한","한다는","할","할당할","할지","함께)","함수","함수도","함수를","함수에","함수의","합니다.","합니다.webpack을","합니다.그것들은","합니다.유효한","합니다.이제","합니다.출력","항목이","해결책은","해당","해제할","핸드북을","했습니다!","허용할","허용합니다","허용해준다는","혜택","호출","호출될","호출들은","호출하여","호출할","혹시","확보할","확실할","확인","확장자로","확장자를","활성화되면","활성화하여","활성화해야","후에","후에는","후위","훨씬"],"pages/tutorials/React & Webpack.html":["\"./components/hello\";","\"./dist/\",","\".tsx\"]","\"commonjs\",","\"compileroptions\":","\"es6\",","\"hello","\"jsx\":","\"module\":","\"namespac","\"noimplicitany\":","\"outdir\":","\"pre\",","\"production\",","\"react","\"react\"","\"react\",","\"react\":","\"react\";","\"react\"나","\"react\"를","\"react\"와","\"reactdom\"","\"sourc","\"sourcemap\":","\"t","\"target\":","&","'.js'","'.ts'","'.tsx'","'helloprops'는","'sourc","(add","(creat","(initi","(instal","(lay","(props:","(put","(write",");","*",",","..",".j",".js파일로","//","/\\.js$/,","/\\.ts(x?)$/,","/node_modules/,","=","=>","@types/","@types/react","[","[\".ts\",","]","_","`{}`","cd","cdn","cdn(content","class","cli","code)","compiler:","compon","components/","configur","const","deliveri","dependencies)","dev","devtool:","dist/","dist의","dist폴더를","document.getelementbyid(\"example\")","dom","dom\":","dom\";","dom\"과는","dom을","dom의","enforce:","exclude:","export","extend","extensions:","extern","externals:","facebook은","file)","framework:","guide를","hello","hello.tsx","hello.tsx에","helloprop","helloprops)","import","index.html","index.html을","index.tsx로","index.tsx를","init","instal","interfac","jqueri","link","loader","loader\"","loader'에서","loader:","loader가","loader는","loader를","loader와sourc","main.j","map","map\",","mkdir","mode:","module.export","module:","network)에서","node.js를","node_modul","npm","npm과","npx","out","package.json","pattern\"이라고","proj","proj/","project)","proj라고","proj의","props의","quick","react","react!","react!\"","react.compon","reactdom","reactdom.render(","react를","react와","render()","resolve:","return","rules:","save","sourc","src","src/","src/compon","src/components에","src에","start","state는","string;","test:","together)","true,","ts","tsconfig.json","tsconfig.json이라는","typescript","typescript는","typescript를","typescript와","typescript의","use:","webpack","webpack.config.j","webpack에","webpack으로","webpack은","webpack을","webpack의","webpack이","y","{","{props.compiler}","{props.framework}!;","{this.props.compiler}","{this.props.framework}!;","}","},","};","└─","├─","가능한","가이드는","가정하고","가정합니다.","가져오고","가져오기를","가져오면,","가져오지만,","가져올","가져왔습니다.","같은","같이","개발","거쳐","것","것에","것을","것이","것입니다.","것입니다;","경로가","경로를","경우,","계속","고급스럽게","고유한","구성","구성에","구성하겠습니다:","구성합니다:","궁금할","그냥","그러나","그렇지","기본","기본값으로","기존의","끝납니다.","나","나중에는","나타납니다.","나타냅니다.","내에서","내용은","내용을","다른","다시","다음","다음,","다음과","다음으로,","단일","달리,","대부분의","대신","대한","대해","더","덜","도구입니다.","도와줍니다.","독립형","동일한","되기","되었습니다!","들어있는","디렉토리부터","디렉토리에","디렉토리의","디버깅","디버깅을","디버깅하는","때","때,","때문에","때문에,","라는","라이브러리는","라이브러리를","로더는","루트에","를","리액트","마법을","마지막엔","만들","만들고","만들어야","맵","맵을","맵이","먼저","먼저,","모두","모듈을","모든","모아서","목록과","묶는","묶지","및","바꿀","방금","방법을","방식으로","방식을","배치","버전의","번째","변경하지","변경할","변수가","변수를","변수에서","보다","복사본에","복사하거나,","봅시다.","불러오기","브라우저","브라우저가","브라우저는","브라우저에서","빌드간에","빠르게","뼈대로","사용하고","사용하면","사용하여","사용하지만,","사용할","사용합니다.","사용했다는","살펴보세요.","살펴볼","상대","새","새로운","생각할","생성됩니다.","생성하고","생성하고,","생성하기","생성할","생성합니다.","선언","선택적으로","설정되지","설정을","설치","설치되어","설치했다는","소스","소스를","수","수도","시","시간이","시나리오입니다.","시작하겠습니다.","시작하기","시작하는","시작하여,","실행한","실행합니다:","싶다는","쓸","아님을","아직","안에","않기","않는","않습니다.","않아도","않으면","않으면,","않으므로,","않은","알","알려줍니다.","알립니다.","알아볼","없다는","여기를","여기에서","연결하는","연결할","열고","예제는","예제를","와","우리가","우리는","원하는대로","원할","웹","웹팩","위해","위해,","유의하세요.","유의해주세요","유일한","의미합니다.","의존성","의존성들은","의존성에","의존성으로","의존성을","이","이것에","이것은","이것을","이동하기","이런","이렇게","이름을","이미","이상적으로","이용하여","이제","일반적으로","일반적인","일치하는","읽을","입니다.","입력","입력하면","있게","있기","있는","있는지","있다고","있도록","있습니다.","있으며,","있지","있지만,","자세한","자세히","자체를","작성된","작성하기","작성하는","작성하려는","작성하세요:","작성해","전역","전통적으로","접두사는","제공하며,","조금","좋습니다.","준비가","중","중요합니다.","즐겨","증가하고","지금은","지원하지","지정하지만,","직접","참조하세요.","찹조합니다.","찾는","찾습니다.","찾았습니다.","채우세요:","처럼","처리한","첫","초기화","최종","추가","추가하겠습니다:","추가합니다.","출력","출력물에서","출력을","캐시","컴파일","컴파일러를","컴파일하도록","컴포넌트는","컴포넌트를","코드","코드를","코드와","타입을","통해","파일","파일과","파일로","파일에","파일은","파일을","파일이","패키지","패키지도","패키지로","패키지에","패키지에는","페이지가","페이지도","페이지에","포함","포함되어","포함시킵니다.","포함하는","폴더","폴더를","폴더에서","표시할","표준","프로젝트","프로젝트를","필드에","필요가","필요한","필요합니다.","하기위해","하나와","하나의","하려면,","하며,","하면","할","함께","함수","합니다.","해당","해줍니다.","허용합니다.","형태를","호스트","호스팅합니다.","확인","확인합니다.","확장자로","활용할"],"pages/Basic Types.html":["\"","\".\\n\\n\"","\"angl","\"blue\";","\"free\"];","\"hello\"];","\"hello,","\"i'll","\"mayb","\"thi","\"world\";","\"날","${","'3'이","'5'가","'[string,","'green'이","'let'에","'number'에는","'object'에","'red';","'substring'","'tofixed'는","(\")나","(')를","(`","(age","(array)","(boolean)","(enum)","(introduction)","(number)","(object)","(somevalu","(somevalue).length;","(string)","(tabl","(true)","(tuple)","(type","(예외적으로","(하지만",")","+",",","//","0","0b1010;","0o744;","0xf00d;","0대신","0부터","1","1)","1,","100;","10];","10진수","16진수,","1부터","2,","2015에","2라는","2인","2진수,","37;","3];","3rd","4;","4}","6;","8진수","=","[\"hello\",","[1,","[10,","[]를","[string,","`","`bob","`hello,","ag","age:","any[]","any와","any의","api","array","array:","assertions)","bigint,","binary:","blue","blue}","bobbington`;","boolean","boolean,","bracket\"","c#","c:","color","color.green;","color:","color[2];","colorname:","console.log(\"thi","console.log(colorname);","console.log(x[0].substring(1));","console.log(x[1].substring(1));","console.log(x[5].tostring());","contents)","create(\"string\");","create(42);","create(false);","create(null);","create(o:","create(undefined);","create({","decimal:","declar","do'","don'ts에","ecmascript","enum","enum은","enum의","enum입니다.","error(\"someth","error(message);","error(message:","es2015에서","expr","fail()","failed\");","false;","fullnam","fullname:","function","green","green,","hex:","i'll","ifitexist","infiniteloop():","instead\";","isdone:","javascript","javascript,","javascript로","javascript와","javascript의","javascript처럼","javascript처럼,","jsx와","let에","let을","library.","list:","list[1]","message\");","month.\";","month.`;","n:","name","never","never는","never로","never를","never에","never타입은","new","next","note:","notsur","notsure.ifitexists();","notsure.tofixed();","notsure:","null","null(","null):","null,","null;","null과","null로","number","number,","number[]","number]'","number];","number라는","object","object.cr","object가","object는","object로","object를","octal:","old","parti","prettysure.tofixed();","prettysure:","primit","prop:","return","sentence:","sentence선언과","somevalue:","strictnullchecks`","strictnullchecks를","strictnullchecks을","string","string\";","string).length;","string):","string,","string으로","strlength:","structnullchecks를","symbol,","throw","tofixed는","true,","typescript는","typescript도","typescript를","typescript보다","typescript에서","typescript에서는","typescript의","u:","undefin","undefined;","undefined는","undefined를","unus","unusable:","var","var대신","var보다","void","void;","void는","void를","void에","void처럼","warn","warnuser():","x","x:","x[3]","year","{","{red","{red,","|","}","});","}.","}과","가","가끔,","가능한","가능합니다)","가능합니다.","가드에","가장","가정합니다.","가지","각각","각자","간단한","감싸는데","감싸지며,","값과","값들은","값들을","값들이","값에","값을","값의","값이","값이든","값이라고","값입니다.","강력한","같다고","같습니다.","같은","같을","개발자가","개수가","객체","거의","건","걸","걸쳐","검사를","검사하지","것","것은","것을","것입니다.","것입니다:","경우","경우,","경우는","고정된","과","관하여","구조체,","구체적일","권장합니다.","그","그런데,","그렇듯,","기능","기본","기본적으로","기본적으로,","기본적인","기존에","나머지를","나은","나중에","나타납니다.","나타내고","나타내기","나타내는","나타냅니다.","난","내가","는","다","다루는","다룰","다룹니다.","다른","다음","단","단언","단언(type","단언만","단언에는","단언은","단위가","대개,","대부분의","대신","대신에","대해","더","더불어,","데","데이터","데이터.","데이터를","도","도달할","도움을","도움이","동일한","동일합니다.","동일합니다:","동적인","될","될만한","두","둘","뒤에","들어,","들어:","따라,","따른","때","때,","때가","때는,","때만","때문에","때문에,","때문입니다:","또는","또는,","또한","또한,","런타임에","런타임엔","리터럴도","리터럴에","마세요.","마지막에","만","만들","많은","말해주는","매겨진","매기도록","매깁니다.","매칭되는지","메서드가","멤버","멤버들의","멤버와","멤버의","몇","모두","모든","목적에","목차","못하게","못하는","못할","문법","문법입니다:","문자로","문자열","문자열,","문자열은","문자열을","문제들이","뭘","미치지","믿어,","바꿀","밖에","반대","반환","반환하는","반환하지","받은","발생시키거나","발생하며","발생할","발생합니다.","방법으로","방법으로,","방법은","방법은,","방법입니다.","방지하는","배열","배열로","배열을","백틱/백쿼트","번째","번호를","베열","변수","변수들에","변수들은","변수를","변수에","변수에는","변환(형","변환)과","보통","볼","부동","부울입니다.","분명히","불리언","붙여줄","붙혀집니다.","비슷한","사용자로부터","사용하면","사용하면,","사용하셔야","사용하여","사용하지","사용할","사용할지는","사용합니다.","사용해","사용해서","살펴보겠지만,","상급","생각할","서버","섞인","선언","선언된","선언하는","선택입니다.","선호에","설명","설정하여","설정할","성공","성공,","섹션을","소개","소개되었고,","소개된","소수","소수에는","수","수는","수도","수동으로","수행했다고","숫자","숫자,","숫자는","스크립트는","스타일의","시간에","시작하여","시작해","실제","실제로","실패합니다.","심지어","싶은","싶을","쌍으로","쓰는","쓰면,","쓰이는","쓰입니다.","쓸","아닌","아닙니다.(never","아래","아무","안전하다는","않고,","않는","않는다고","않습니다.","않으며,","않은데,","않을","않을때만","않음)","알","알고","알아\"라고","알아낼","알지","애플리케이션을","어떤","언어들처럼,","언어에서","언어의","언어처럼,","얻게","얻지","없는","없다.","없습니다!","없습니다.","없습니다:","없을","없음을","에러를","엔티티의","여겨지고","여러","역할을","열거","영향을","예)","예를","예제는","예제를","예제에서","예제입니다:","오류","오류,","오류:","오류가","오류를","오직","온전히","올","왜냐하면","외에","요소들을","요소들의","요소에","요소의","원시","원합니다.","웹","위","위는","위의","위치한","위해","위해,","유니언","유사하지만,","유용하려면","유용하지","유용한","유용합니다.","은","을","의미합니다.","의해","이","이건","이건,","이는","이런","이를","이름으로","이름을","이에","이용했다는","이유로,","이후","익숙할","인덱스","인덱스에","인지합니다.","일반적인","일부만","일을","일치하는","일컫는","임의로","입니다.","있거나,","있게","있기","있는","있는지","있다는","있습니다.","있습니다:","있으며,","있을","자료형","자세한","자세히","자신들","자신은","자신의","자체로","작성할","작업이","작업할","작은따옴표","잘","잘못된","재구성하지는","전체는","절대","점진적으로","접근하면","접근하면,","정해진","제네릭","제외)","존재하더라도,","존재하지","존재할","존재합니다.","좁혀지면","주로","주제로,","줄에","줍니다.","중","중에","지금까지","지원하며,","지원합니다.","집합과","집합에","참/거짓(true/false)","참고)또는","챕터에서","첫","초기화","최대한","추론된다.","출력됩니다.","컴파일","컴파일러는","컴파일러만","컴파일러에게","콘텐츠에서","큰따옴표","키워드","키워드는","키워드를","타입","타입과","타입니다.","타입도","타입보다","타입에","타입에는","타입에만","타입으로","타입은","타입을","타입의","타입이","타입인","타입입니다.","테이터","텍스트","템플릿","통과하길","튜플","특별한","특정","페이지,","편리하게","포함시킬","표준","표준으로","표현식에서","표현식을","표현식이나","표현하기","표현할","표현합니다.","표현해야","프로그램을","프로그램이","프로퍼티","필요는","필요한","필요합니다.","하거나","하고","하나는","하나는,","하나의","하위","하지","하지만","하지만,","할","할당","할당할","함께","함수","함수는","함수에서","함수의","합니다.","항상","해결되며,","해당","해당,","해주지만","해줍니다.","핸드북의","했듯이","허용됩니다.","허용하고","현재","형은","형태가","형태로","호출할","혹","혹은","화살표"],"pages/Variable Declarations.html":["\"\"","\"$$\",","\"aurora\",","\"a를","\"bar\"","\"baz\",","\"cat\";","\"danielle\",","\"foo\",","\"hello!\";","\"hello\",","\"hello,","\"kitty\";","\"noisy\"","\"oh","\"rich\"","\"rich\",","\"rich\"를","\"rory\";","\"seattle\";","\"spicy\",","\"yes\"","\"성공\"","\"존재\"하지만,","\"환경\"을","'0'","'10'","'100'","'11'을","'2'","'a'","'a'를","'b'는","'e'는","'undefined'","'x'를","'때에","(array","(block","(condition)","(const","(default","(destructuring)","(e)","(function","(input)","(let","(object","(properti","(re","(scope","(shouldinitialize)","(spread)","(true)","(tupl","(var","(variabl","({","+",",","...","...bc]","...c","...d]","...default","...defaults,","...first,","...passthrough","...rest]","...second,","...로","//","0","0);","0;","1","1,","10","1001","100;","101","10;","10을","10이라는","10입니다.","12,","12;","1;","2","2,","2015","20;","2;","2]);","2];","3","3,","3;","3에","4","4,","4];","5","5];","5]라는","6","7","8","9","9;",";","=","[","[,","[0,","[1,","[3,","[7,","[],","[a,","[a]","[first,","[first]","[number,","[second,","[string,","]","`a`가","`foo`","`x`를","a++;","a,","a:","a;","a=\"\",","ambiance:","a라는","a를","a에","a와","a의","b","b,","b:","b;","b=0","b?:","b?는","b]","bc:","boolean","boolean)","boolean]","bothplu","bothplus에","b가","b는","b를","c","c();","c):","c,","c:","c]","captur","capturing)","catch","citi","city;","city를","city에","class","clone","clone.m();","clone.p;","console.log(\"oh","console.log(e);","console.log(first);","console.log(fourth);","console.log(rest);","console.log(second);","const","const가","const는","const를","c를","d:","d]","dead","declar","declarations)","default","defaults안에","destructuring)","develop","ecmascript","es2015를","expression)를","f","f()","f();","f([1,","f([first,","f(condition,","f(false);","f(false,","f(input:","f(shouldinitialize:","f(true);","f(true,","f(x)","f({","f({});","first","first,","first];","first와","foo()","foo();","food","food:","fourth]","function","function()","f가","f의","g","g()","g();","getciti","getcity();","getcity;","g가","g는","hello","if문의","iife를","immedi","input","input;","input[0];","input[1];","interfac","invok","i가","i를","i의","javascript","javascript는","javascript를","javascript에서","javascript에서는","javascript의","javascript이기","keepwholeobject(wholeobject:","keepwholeobject는","kitti","kitty.nam","kitty.numl","let과","let문","let선언만","let선언은","let은","let을","let의","loop","m()","messag","message;","mozilla","name:","network를","network의","new","newname1","newname1,","newname2","no!\";","number","number,","number[][])","number])","numlives:","numlivesforcat","numlivesforcat,","o","o.a,","o.a;","o.b;","o.b로","o;","p","passthrough.b","passthrough.c.length;","price:","quirks)","renaming)","return","rules)","scope","scoping)","search","search는","second","second,","second]","second]:","second라는","second의","settimeout","settimeout예제를","settimeout은","settimout에","shadow","shadowing)","shadowing은","shadowing의","shadowing이라고","string","string,","sum","summatrix","summatrix(matrix:","templor","tempor","thecitythatalwayssleeps()","throw","total","tri","true];","tuple:","tuple;","type","typescript","typescript가","typescript는","typescript를","typescript에서는","undefin","values)","var","variabl","var로","var보다","var선언은","var에","var와","void","vs.","well.\");","wholeobject;","wholeobject라는","world!\";","x","x)","x;","x는","x를","x의","zone에","zone입니다.","{","{}):","{를","}","})","}):","});","}:","};","}입니다.","가","가깝게","가능한","가능합니다.","가르치며,","가리기","가리킵니다.","가장","가지","가지고","가지는","가진","가집니다.","각각","간단하게","간단한","간단히","감싸고","감춰","값","값으로","값은","값을","값이","강화된","같게","같은","같을","같이","개발자는","개발자들은","개요를","객체","객체를","객체의","객체입니다.","거라고","거치며","건너","걸","걸쳐","검이라고","것","것과","것도","것들은","것만","것으로","것은","것을","것이","것이었습니다.","것입니다.","것입니다:","것입니다;","결과가","결과는","결과를","결함을","경우","경우,","경우에는","경험","계산할","고려할","고맙게도,","고치도록","고통스러운","과제를","관계없이","괄호로","광범위한","구문","구문을","구문이","구조","권한의","규칙","규칙들을","규칙은","규칙을","그","그들이","그래서","그러나","그런","그렇게","그리고","그리고,","글을","기능은","기능이","기능입니다.","기다리며)","기본","기본값","기본값,","기본값으로","기본값을","기본적으로,","기억을","기억하나요?","기억하세요:","기억해야","기존","깊게","까다로울","나머지","나머지를","나중에","나타내지","난","내려야","내부","내부에","내용은,","내용을","냅니다.","넘어갈","넘어선","넣어야","네임스페이스,","놀라운","놀란","놀랐더라도","다는","다르다'입니다.","다른","다릅니다.","다음","다음,","다음과","다행히","다행히,","단","단순한","단점","단점들에","단지","달리,","답은","당신","당신은","당연히","대로,","대부분","대상으로한,","대신","대신,","대해","더","더욱","던질","덮어쓰는","덮어쓰는데,","덮어쓸","데이터의","도와줄","도입하게","동일하지만","동일한","동작에","동작이","동작이므로,","동작하게","동작하는지","동작합니다.","동작합니다:","되기도","되면","되었는데,","되었습니다.","된다는","됩니다.","됩니다:","두","둡니다.","뒤따라","뒤에","들어,","따라","따라서","때","때,","때마다","때문에","때문에,","때문입니다.","떠올려","또","또는","또한","또한,","뛸","뜻인지","뜻합니다:","런타임에","런타임은","렉시컬","로\"","루프","루프가","루프는","루프의","를","리뷰를","마주치는","마지막에","마찬가지로,","막기","만드는","만들","만들어","만듭니다.","만약","만약에","많은","많이","말로","말씀드리자면,","말해주듯이,","매","매개","매개변수를","매개변수에","매개변수에도","매번","머뭇거릴","먼저,","멈추고","멈추는","메서드를","멤버가","명시하는","명확한","몇","몇몇의","모두","모듈,","모든","무슨","무시할","문에","문은","문제를","문제에","문제점에","물론","밀리","바깥","바깥에서도","바꾸기","바꿀수","바로","바인딩","밖에","밖에서","반대입니다.","반드시","반복될","반복마다","반환","방법으로","방법은","방법입니다.","방생되어","방식들과","방식들이","방식이며,","방지합니다.","방해합니다.","방향은","배열","배열과","배열을","배열처럼","버그는","버그를","버그의","버립니다.","버전에서","번","번째로,","범위로","범위를","변경,","변경할","변수","변수가","변수는","변수들에","변수들은","변수들이","변수로","변수를","변수에","변수에는","변수에도","변수의","변하지","별개의","보겠습니다:","보고하지","보단","보면","보면,","보세요.","보세요:","보았을","보이는","보통","복사를","복잡합니다.","본인의","봅시다.","부를","부릅니다.","부분","부분들이","부분을","부터","분들은","분들을","분해","분해가","분해는","분해된","분해될","분해됩니다;","분해를","분해와","분해의","분해입니다.","분해처럼,","분해할","불가능하다는","불리는","불변이라고","붙히는","블록","블록과","블록까지로","블록에","블록으로","블록의","비교적","비슷하지만","비슷한","비어있는","빼고는","사람들이","사실","사용.","사용되는","사용을","사용자가","사용하고","사용하는","사용하는지는","사용하도록","사용하면","사용하세요.","사용하여","사용합니다.","사용해","사용해서","사용해야","사용했던","사용했습니다.","살펴보겠습니다.","살펴보겠습니다:","살펴보세요.","살펴보았습니다.","살펴볼","상위","상의하세요.","상태는","상황을","상황이","새로","새로운","생각합니다.","생각해","생성됩니다.","생성할","생성합니다.","선언","선언과","선언되기","선언되는","선언되어","선언되어야","선언되었을","선언된","선언될","선언에","선언에서도","선언은","선언을","선언의","선언이","선언입니다.","선언하는","선언하는지는","선언하면","선언할","선언했습니다.","선택적","선택적으로","선택적이라는","선택해야","선호되는지를","설명되어","설명은","설명합니다.","성공","성공,","섹션에서는","섹션이","손으로","수","수도","수정","수정될","수정하려는","수정하면:","수정할","쉐도잉","쉽게","스스로","스왑","스코프","스코프가","스코프는","스코프라고","스코프에","스코프에서","스코프의","스코프입니다.","스코핑(block","스코핑(lexic","시작으로","시작합니다.","시키겠지만.","실수로","실수를","실제론,","실행","실행되면서","실행될","실행됩니다.","실행을","실행이","실행하는","실행합니다.(다른","심각하게","심지어","써왔던","쓰는","쓰이기","아니라는","아닙니다.","아래","아마","아무렇게나","안","안된","안에","안에,","안에서","안의","안쪽","않는","않다고","않습니다.","않았을","않은","알","알게","알고","알다시피,","알려주기","알려줍니다.","알아두면","알아두세요.","알아차리겠지만,","앞서","앞에","앞에서","앞의","약간의","양날의","얕은","어느","어떤","어떻게","어쨋든","언급했던","언급했듯이,","언어와","언제나","언제든","얻게","얻기","얼마나","없다는","없다면","없더라도","없습니다.","없어야","없이","에러가","에서는","여기,","여기서","여기서는","여러","여전히","여태","연산자는","열거","예를","예상","예상되는","예상해","예제를","예제에서","예제에서,","예제이며","예측하기","오는","오류","오류!","오류,","오류:","오류를","오류입니다:","오른쪽으로","오른쪽입니다:","오직","올바르게","와","완료되었음에도","왜","왜냐하면","왼쪽에서","요소가","요소나","요소들에","요소들을","요소를","요소와","우리가","원인이","원칙을","위","위에서","위와","위해","위해서","유발할","유사하지만,","유사한","유지하세요.","유형의","유효합니다.","을","의도한","의미를","의미에","의미합니다.","의해","이","이건","이것은","이것을","이게","이고","이는","이더라도","이들은","이라","이런","이를","이름","이름에서","이름을","이름의","이미","이번","이상한","이상해","이외에","이외의","이용해","이용해서","이유","이유는","이유는,","이전","이전에","이점을","이제","이제,","이해하기가","이해해","이후","익숙하지","익숙한","인덱스","인덱싱을","인스턴스를","일","일단","일반적으로","일반적이며,","일반적인","일부로","일으키거나,","일이지만,","일치하는","읽거나,","읽기","읽을","잃게","입니다.","잇습니다.","있게","있겠지만,","있기","있는","있는데,","있는지","있다는","있다면","있듯이,","있습니다","있습니다.","있습니다.:","있습니다:","있었다면,","있었던","있으므로,","있지만,","자동으로","자세한","자세히","자주","자체에","작고","작성됩니다.","작성을","작성해야","작성했다고","작업의","작업하는","잘","잘못된","잠시,","잡아","잡아두는","잡아둘","재선언과","재할당","재할당을","재할당할","적용하면,","적합한","전개","전개는","전개보다","전개에","전개처럼","전개하는","전개하도록","전개하면","전개할","전까지","전달하는","전에","전역","전용(readonly)이라고","전체","점은","접근할","접근해","정교한","정도","정말","정의되지","정의했다는","제네릭","제대로","제한점이","조치를","존재하지","존재합니다.","종료한","종류의","종종","좌절의","주세요.","주어야","주어지면","주어진","주요한","주의할","주의해","주의해서","준비됐나요?","줍니다.","중복해서","중요하지","중지했을","중첩된","즉시","지역","지원합니다.","지정하는","지정할","직관적입니다:","진행되지만","질문처럼,","집합이므로,","짧은","차이점은","참고","참조하고","참조하는","참조할","참조합니다.","찾을","챕터에","처럼","처음","첫째로,","초","초기화","최선의","최소","최신","추론의","추론할","출력","출력됩니다.","출력할","취하지","캡처는","캡처된","캡쳐되면","캡쳐된","캡쳐링","캡쳐링에","캡쳐링을","캡쳐링의","캡쳐하기","캡쳐했기","컴파일러는","코드","코드는","코드를","코드베이스에서","코드의","콜론은","크게","키워드를","타입","타입스크립트","타입을","통해","튜플","튜플은","튜플을","튜플의","특별한","특정","특징은","팀원들과","파싱","판단을","패턴을","패턴이","패턴입니다.","편리합니다:","편이지만,","포함한","표시가","표현식","표현식은","표현식을","프로퍼티","프로퍼티가","프로퍼티는","프로퍼티들에","프로퍼티를","프로퍼티만","프로퍼티에","프로퍼티와","피하기","피할","피합니다.","필요","필요가","필요는","필요하지","필요합니다.","하고","하고,","하나만","하는","하세요.","하지만","한,","한다는","한번","한정되지만,","한정됩니다.","할","할당은","할당입니다:","할당할","할필요가","함께","함수","함수(iif","함수,","함수가","함수까지","함수를","함수에서","함수의","합니다.","합니다:","합을","항상for루프가","해당","해당되는","해당한다는","해줍니다.","핸드북에서","핸드북은","했기","했던","했습니다.","허용되며,","허용하지","현재","형태는","호출","호출된","호출될","혹은","혼동하면","혼란스러워지기","혼란스럽게도","혼란스럽습니다.","혼자만","환경","환경과","환경을","활용할","후에","후에도","후에도,","훨씬","흐름을","흘러나오는","힘듭니다."],"pages/Interfaces.html":["\"100\"","\"black\"});","\"blue\";","\"bob\"];","\"fred\"];","\"mallory\";","\"option","\"red\"","\"red\",","\"size","\"string\";","\"white\",","\"구조적","\"대상","\"덕","\"사전\"","\"인덱스로\"","\"피하는\"","'(src:","'boolean'.","'clor'","'color'?","'colour'","'image'.","'searchfunc'.","'squareconfig'","'squareconfig'.","'state'","'string'","()","(3rd","(call","(class","(config.clor)","(config.color)","(config.width)","(construct","(contextu","(control을","(differ","(excess","(extend","(function","(hour:","(hybrid","(implement","(index","(interfac","(introduction)","(number)로","(option","(our","(readonli","(source:","(start:","(string)로","(structur","(target","(여기서는","*","...","//","0.5","10","10,","100","100,","100;","100};","10;","12,","123;","12;","17);","1;","2,","20","3,","32);","32)안에","4];","5.0;","5;","7,","=","=>",">","?를","[\"alice\",","[\"bob\",","[1,","[index:","[propname:","[x:","`name`의","a:","a;","a[10]","agemap[\"daniel\"]","analog","analogclock","analogclock이","anim","animal;","animal을","any;","area:","array와","assertion)으로","assign","bags\"","bags\"을","beep\");","between","boolean","boolean;","breed:","button","button과","c","c#과","c(10);","c.interv","c.reset();","checking)를","checks)","class","classes)","clock","clock:","clockconstructor","clockconstructor,","clockconstructor는","clockinterfac","clockinterface;","clockinterface는","color","color:","color?:","color나","color대신","color와","colour","colour:","colour로","config.clor;","config.color;","config.width","config.width;","console.log(\"beep","console.log(\"tick","console.log(labeledobj.label);","const","constructor(h:","const를","control","control과","control의","counter","counter.interv","counter.reset","counter;","createclock","createclock(analogclock,","createclock(ctor:","createclock(digitalclock,","createclock의","createsquare(config:","createsquare(squareoptions);","createsquare({","createsquare({color:","createsquare를","createsquare안의","createsquare에","createsquare의","ctor(hour,","currenttime:","d;","date","date();","date)","date):","date;","digit","digitalclock","dog","dog;","error:","exist","extend","false와","first","function","function(source:","function(src,","function(src:","getcounter():","getcounter();","hour:","imag","image와","implement","index","instanc","interfac","interface)","interfaces)","interval:","javascript","javascript는","javascript에선","javascript와","javascript의","java와","known","label","label:","labeledvalu","labeledvalue)","label을","length:","length는","liter","locat","m:","mean","methods)가","minute);","minute:","miss","myarray","myarray:","myarray[0];","myarray[2]","myarray[2]의","myobj","mysearch","mysearch:","mysquar","mystr:","name:","name은","name의","new","newsquar","newsquare.area","newsquare.color","newsquare;","notokay","number","number)","number):","number);","number,","number;","number[]","number[];","number]:","numberdictionari","numberorstringdictionari","number}","number로","obj.property가","obj[\"property\"]로도","object","object\"};","opacity:","p1.x","p1:","party)","penstrok","penwidth:","point","point를","printlabel","printlabel(labeledobj:","printlabel(myobj);","printlabel에","privat","private과","private에서는","properti","properties)","properties,","protect","public과","public을","readonli","readonlyarray","readonlyarray를","readonlystringarray","readonly를","readonly와","reset():","result","return","ro","ro.length","ro.push(5);","ro:","ro;","ro[0]","searchfunc","searchfunc;","select","select()","select():","selectablecontrol","selectablecontrol를","selectablecontrol은","selectablecontrol의","settim","settime(d:","shape","shape,","side","sidelength:","signatuer)을","signature)로","signature)를","size:","source.search(substring);","specifi","squar","square.color","square.penwidth","square.sidelength","square;","squareconfig","squareconfig):","squareconfig);","squareconfig가","squareopt","squareoptions가","squareoptions와","src.search(sub);","state","state:","state는","static","string","string'","string)","string):","string,","string;","string]:","stringarray","stringarray;","stringarray가","string으로","string을","sub)","sub:","substring:","subtyping)\"이라고도","textbox","this.currenttim","tick()","tick():","tick();","tock\");","true)","type","type)\"이","types)","typescript가","typescript는","typescript에서,","typescript에서는","typescript에서도","typescript의","typing)\"","typing)이","void;","vs","width","width:","width?:","width가","write","x,","x:","y:","y를","{","{color:","{size:","{}","|","}","})","});","};","}를","}을","가끔","가능하게","가능하지만,","가능한","가능함을","가능합니다.","가능합니다:","가능해야합니다.","가장","가졌는지만을","가지","가지가","가지고","가지기","가지는","가진","가진다는","가질","가질수","가집니다.","각","간단한","간단합니다.","값으로","값을","값의","값이","강력한","강제하는","강제합니다.","갖고","갖는","같기","같은","같을","같이","개의","객체","객체가","객체를","객체입니다:","거대한","검사","검사가","검사는","검사를","검사에","검사하기","검사할","검사합니다.","겁니다:","것","것과","것뿐만","것에","것은","것을","것이","것입니다!","것입니다.","것입니다:","게","결합하면","경우","경우,","경우는","경우에,","경우에만","경우입니다.","계약(contract)을","계약을","곳에서","공통","관대하지","관련이","괜찮다면,","구현된","구현될","구현은","구현을","구현하기","구현하는","구현해야","그","그냥","그들의","그래서","그러한","그리고,","기대해도","기술하기","기술하는","기술하는데","기술할","기술합니다.","기억하기","기억하는","기초","기초클래스에서","끝에","나","나열된","나은","나중에","나타냅니다.","납니다.","넓은","넣어서","놀랍게도","높은","다루겠습니다.","다룰","다른","다시","다양한","다음","다음과","단언(type","단언을","단지","대부분은","대신에,","대응되는","대해","더","데","동일한","동작하는","동작하는지","동작하도록","동적이고","될","두","둘을","들어,","들어:","등","때","때,","때나","때만","때문에","때문에),","때문에,","때문이고,","때문입니다.","또","또한","똑같이","뜻이고,","리터럴에서","리터럴은","리터럴을","리터럴이","마주할","마지막","마지막으로,","마찬가지입니다.","막기","만들","만들고,","만들어낼","만약","만약에","많은","말은,","맞는지만","맞추고","매개변수","매개변수가","매개변수끼리","매개변수는","매개변수들은","매개변수로","매개변수의","메서드(mutat","메서드가","메서드를","메시지로","멤버","멤버는","멤버도","멤버들이","멤버를","멤버에","멤버이기","명시적으로","몇","몇몇","모두","모두를","모두보다는,","모든","목록과","문맥상","문자열","문자열과","문자열로","문자열을","문자열입니다","문제가","반드시","반영하도록","반환","반환된","반환하는","반환할","반환했다면,","받고,","받습니다.","받지","발생시킵니다.","발생하는","발생하면,","발생할","발생합니다.","방법과","방법은","방법을","방법이지만,","방법입니다.","방지하면서,","배열에","배열을","배우고,","배웠습니다.","백","버그가","버그입니다.","번째","범위의","변경","변경하지","변수가","변수는","변수로","변수를","변수에","변수와","변환하기","보겠습니다:","보는","보여줍니다.","보장할","복사하는","복잡한","부분을","불가능한","붙여","비슷하게","비슷합니다.","사용","사용을","사용하고","사용하는","사용한","사용할","사용할지","사용합니다","사용해야할","사이에","상속계층을","상속받고,","상속받습니다.","상속받지","상속받지만","상속하는","상태를","상호작용할","색인화(indexed)되면","생각할","생각합니다.","생각해볼","생성","생성될","생성자","생성자가","생성자를","생성하고,","생성하는","생성하려고","생성합니다.","서로","서명","서명(string","서명에","서명은","서명을","서명이","서브타이핑","선언과","선언에서","선언한","선택적","설명하는","설명할","설명했던","성공,","세계에","소개","소위","속성을","속하지","수","수도","수정","수정할","수정해야","수행하는","순서를","숫자","숫자.","숫자입니다","숫자형","쉬운","스태틱","스태틱과","스태틱이기","시그니처","시그니처가","시그니처는","시그니처를","시도하지","시작하는","실제","실제로","실제로는","심지어","싶다면,","써드파티","쓸","아니라","아니라면,","아닙니다","아닙니다.","아래","아래와","아예","안에서","안에서도","안의","않고","않고,","않기","않는","않는다는","않습니다.","않은","않음을","알려주기","알려줍니다:","앞에","얘기할","어디에","어떤","어떻게","언급했듯이,","언어에서","언어처럼","얻게","없고,","없습니다.","없으면","없을","에러가","에러를","에러의","여기서","여기서는","여러","여전히","역할","역할을","예를","예제","예제로","예제를","예제를,","예제에서","예제에서,","예제에서는,","예제의","오류","오류!","오류,","오류:","오류가","오버라이드하는","올바르게","올바른","옵션","완전히","외부에서","외에,","외에는","요구","요구사항을","요구하는","요구하지","원칙","위","위에서","위와","위의","위처럼","위치에","위해","위해,","유래된","유사하게,","유연한","유연함을","유용하다는","유용하지만,","유용합니다.","유의하세요.","유형과","의미합니다.","의해서만","이","이것은","이나","이는","이런","이를","이름","이름과","이름으로","이름을","이름이","이번","이번엔","이용","이유는","이전","이점은","인데스","인덱서(indexer)를","인덱서블","인덱서에서","인덱서의","인덱스","인덱스가","인덱스의","인덱싱","인덱싱을","인덱싱하기","인덱싱하는","인수","인수로","인스턴스","인스턴스를","인스턴스만","인스턴스의","인터페이스","인터페이스가","인터페이스는","인터페이스들도","인터페이스로","인터페이스를","인터페이스에","인터페이스와","인터페이스의","인터페이스처럼","일관성","일반","일반적인","일부","일찍이","일치하도록","일치하지","읽기","읽기전용","입력하면,","있고","있고,","있기","있는","있는지","있는지와","있다고","있다는","있다면,","있습니다.","있습니다:","있어,","있어야","있으면,","있을","있음을","있지","있지만,","자식만","자식에게만","작성되고,","작성되었다고","작성해","잘","잘못","재사용성","재할당이","적합하고,","전달된","전달하는","전달한","전달할","전달합니다.","전달해도","전에","전용으로","전용이기","전혀","접근할","정말","정의되면,","정의된","정의를","정의하고,","정의하는","정의할","정의합니다.","정의합니다:","제거된","제공하지","제공합니다.","제공해줍니다.","조건에서만","조건을","조용히","조합으로","조합을","존재하거나","존재하는","존재하는지와","좀","좋습니다.","좋습니다:","주어진","주지","줄에서","중","중에","중요하지","중요한","즉,","지","지원하는","지정하는데도","지정하지","지정할","직접","직접적으로","질문해","짓는","쪼갤","차이점","채워","처럼","처리를","처음","첫","초과","초점을","최소한","추가","추가적인","추가하는","추론됩니다.","추론할","충족시키도록","충족하면,","컴파일러는","컴포넌트로","코드","코드가","코드에","코드의","클래스","클래스가","클래스나","클래스는","클래스들은","클래스를","클래스에","클래스와","클래스의","클래스처럼,","타이핑","타이핑(duck","타입","타입(subtype)이어야","타입과","타입들을","타입들의","타입만","타입에는","타입으로","타입은","타입을","타입의","타입이","타입이므로,","타입입니다.","통해서","특별한","특성","특정","패턴을","패턴의","편의를","포함되지","포함하여,","포함한","표시합니다.","표현식이","표현을","표현의","프로그램이","프로젝트","프로퍼티","프로퍼티가","프로퍼티는","프로퍼티들도","프로퍼티들은","프로퍼티들의","프로퍼티들이","프로퍼티로","프로퍼티를","프로퍼티만","프로퍼티와","프로퍼티의","프로퍼티중","피하는","필요가","필요는","필요한","필요합니다.","하고","하나는","하나를","하나씩","하나의","하면","하위","하위클래스는","하위클래스에","하위클래스에서만","하위타입이","하위타입이지만","하이브리드","하지만","하지만,","한","한다고","한다면,","한번","한번에","할","할당","할당되었기","할당을","할당하는","할당하여","할당할","할때","함께","함께,","함수","함수는","함수를","함수에","함수와","합니다.","합집합이라면","해당","해주는데,","핵심","허용됩니다.","허용할","허용해주었습니다.","형태를","형태뿐입니다.","형태에","호출","호출을","호환되기","혹은","확신한다면,","확인하는","확인할","확인합니다.","확장(extend)이","확장하기","확장하면,","확장한","확장할","후에","후에는"],"pages/Classes.html":["\"","\"bob","\"greeter","\"greeter라는","\"hello,","\"hey","\"man","\"sales\");","#name:","${distanceinmeters}m.`);","${this.department}.`;","${this.name}","&&","'#name'은","'animal'","'animal'과","'employee'은","'name'은","'person'의","()","(abstract","(accessors)","(advanc","(classes)","(constructor","(ecmascript","(employee.fullname)","(function","(inheritance)","(introduction)","(newnam","(paramet","(point.i","(point.x","(public","(public,","(readonli","(static","(thename:","(this.greeting)","(understand","(use","*","+",".d.t","/","//","0)","0,","0};","1,","10,","10;","10am.\");","10}));","10자가","1x","2,","2015를","3","3.8","3.8에서,","34m.","3};","3개의","3으로의","45)","5","5)","5m.","5x","6로도","8","8;","=",">","_fullname:","`hello,","abstract","account","accountingdepart","accountingdepartment();","anim","animal(\"cat\").#name;","animal(\"cat\").name;","animal(\"goat\");","animal과","animal로","animal에","animal에서","animal의","animal이라는","auditing\");","bark()","bark()와","c#","c#에서는","calculatedistancefromorigin(point:","class","classes)","console.log(\"depart","console.log(\"galloping...\");","console.log(\"gener","console.log(\"roam","console.log(\"slithering...\");","console.log(\"th","console.log('woof!","console.log(`${this.name}","console.log(`anim","console.log(employee.fullname);","console.log(greeter.greet());","console.log(greeter1.greet());","console.log(greeter2.greet());","console.log(grid1.calculatedistancefromorigin({x:","console.log(grid2.calculatedistancefromorigin({x:","console.log(howard.getelevatorpitch());","console.log(howard.name);","const","constructor","constructor()","constructor(message:","constructor(name:","constructor(publ","constructor(readonli","constructor(thename:","dad","dad.nam","default)","depart","department();","department.generatereports();","department.printmeeting();","department.printname();","department:","department;","dog","dog();","dog.bark();","dog.move(10);","dog는","dog은","each","earth...\");","ecmascript","employe","employee(\"bob\");","employee(\"howard\",","employee();","employee.fullnam","employee;","employee는","employee라는","employee를","employee의","error(\"fullnam","extend","fields)","fullname():","fullname(newname:","fullname:","fullnamemaxlength","fullnamemaxlength)","fullnamemaxlength);","fullname을","fullname이","function","functions)","galloping...","generatereports():","getelevatorpitch()","getters/setters를","getters와","getter도","get과","greet","greet()","greeter","greeter(\"world\");","greeter();","greeter(message)","greeter.prototype.greet","greeter.standardgreeting;","greeter1","greeter1:","greeter1은","greeter2:","greeter:","greeter;","greetermaker();","greetermaker.standardgreet","greetermaker:","greetermaker라는","greetermaker에","greeter는","greeter라고","greeter를","greeter의","greeter클래스의","greeting:","grid","grid(1.0);","grid(5.0);","grid.origin.x);","grid.origin.y);","grid.를","grid1","grid2","grid의","hors","horse(\"tommi","horse는","horse와","horse의","howard","interfac","interface)","javascript","javascript는","javascript를","javascript의","java를","john","legs\");","length","makesound():","math.sqrt(xdist","max","meet","message;","modifier)","modifiers)","monday","move","move():","move()를","move(distanceinmet","move(distanceinmeters:","move를","name","name:","name:string이라는","name;","name은","name을","name이라는","new","newname.length","newname;","newname의","new를","number","number)","number;","number;})","numberoflegs:","octopu","octopus(\"man","octopus의","octopus클래스입니다.","origin","origin에","palomino","palomino\");","person","person(\"john\");","person에서","person을","piec","point","point3d","point3d:","printmeeting():","printname():","privat","private)","private,","private으로","private을","private지정자와","properties)","protect","protected)","protected,","protected로","public","public,","public으로","public을","public입니다.","python","python\");","readonli","readonly도","readonly로","readonly키워드를","reports...\");","return","rhino","rhino();","rhino;","rhino가","rhino는","sam","sam.move();","sammi","scale","scale:","set","setters가","setter를","set을","set이","slithering...","smith\";","snake","snake(\"sammi","snake.","snake와","standardgreet","static","static을","string","string)","string,","string;","strong","suit\";","super(\"account","super(\"rhino\");","super()를","super(name);","super.move(distanceinmeters);","techniques)","thename;","thename을","thename의","thename이라는","there!\"","there!\";","there\"","there\";","this.#nam","this._fullnam","this._fullname;","this.depart","this.greet","this.greeting;","this.nam","this.name);","this.scale;","this.를","this에","throw","tom.move(34);","tom.move(34)는","tom:","tommi","tom은","typeof","typescript","typescript’","typescript는","typescript에는","typescript에서","typescript에서는","typescript에서는,","typescript의","void","void;","woof!');","work","world\"","world\"\"","x:","xdist","y:","ydist","ydist)","z:","{","{x:","}","})();","};","가능하다고","가능합니다.","가로채는","가장","가지","가지고","가지를","가지므로","가진","각","각각","각각의","간단한","값에","값을","값의","값이기","같아보이는","같은","같이","개발자들이","개의","개정된","객체","객체가","객체를","객체에","객체의","거의","검증하기","것","것과","것에","것은","것을","것이","것입니다.","것처럼,","격리를","경우는","고급","곳에서","곳으로","공개","공유하기","공유합니다.","구문일","구조적인","구현","구현되어야","구현을","규칙입니다.","그","그러나","그렇지","그리고","기능을","기다릴","기반","기반의","기법","기법들을","기본적으로","기본적인","기존","기존의","기존의javascript로","기초","길이를","길이와","나와있습니다.","나타내는","내에서","내에서는","내의","내장되어","넘는","노출","노트에","느낄","다","다룹니다.","다르게","다른","다소","다음","다음과","다음으로,","다음은","달리","대한","대해","대해서만","더","더욱이","덧붙이는","데이터베이스","동시에","동일하게","동일한","동작하게","동작합니다.","된다는","된다면,","두","두개의","둘","둘째,","들면,","들어,","때","때,","때는","때문에","때문에,","때문입니다.","또","또는","또한","라고","런타임에","레퍼런스를","릴리즈","마지막","마찬가지로,","만드는","만들","만들고","만들고,","만들기","만들어지는","만들어진","만약","말합니다.","맞게","매개변수","매개변수를","매개변수에","매우","먼저","메서드","메서드가","메서드는","메서드로","메서드를","메서드와","멤버가","멤버는","멤버들에","멤버를","멤버에","멤버에도","멤버와","멤버의","명시적으로","몇","모두","모두를","모든","못하도록","무조건","문법은","문법을","문제가","및","반드시","발생시킵니다.","발생함을","발생합니다.","방법은","방법을","방법이","방식에","방식으로","방식을","백업","버전에서는","버전의","번째로","변경할","변수는","변수들을","변수를","변환해봅시다.","보여주기","보여주는","보여줍니다.","보이는","보이는지","보장할","복잡한","본","본문을","부분은","부분을","불리기도","불리는","붙여","붙여야","붙이는","붙입니다.","브라우저와","비공개","비공개로","비교할","비슷하게","비슷한","사람들이","사용됩니다.","사용자들이","사용하기","사용하는","사용하도록","사용하면","사용하여","사용하지","사용한","사용할","사용함으로써","사용합니다.","사용해봤다면,","사용해서","사용했지만,","사항:","살펴보겠습니다.","살펴보겠습니다:","살펴보았습니다.","상관없이","상속","상속받고","상속받습니다.","상속을","상위클래스(superclasses)","새로운","생각하는","생성됩니다.","생성자","생성자가","생성자는","생성자를","생성자에","생성자에서","생성자와","생성하고","생성하기","생성하여","생성할","생성합니다","생성합니다.","생성합니다:","선언","선언과","선언되어","선언되었지만","선언된","선언에","선언으로부터","선언은","선언이","선언하고","선언하면","선언한","선언합니다.","선언했습니다.","선택적으로","설명합니다.","설정될","설정할","설정해야","성질입니다.","세밀하게","세부","섹션의","소개","수","수도","수정하지","수정해봅시다.","수행된","시스템입니다.","시작으로","시작합니다.","시킬","식별자이기","실제로","실행할","실행해","심볼의","아니기","아니라","아닌","안에서","않고","않는","않다는","않습니다","않습니다.","않아도","않으며","않은","알","알려진","알리기","알아보기","앞서","앞에","앞에서","애플리케이션을","어디서","어떻게","어색함을","언급하지","언급한","언어를","언어의","얻습니다.","없는","없습니다","없습니다.","없음.","없음을","없이","없지만","없지만,","여기서","여기서,","여기선","여러","여전히","예:","예를","예제는","예제로","예제를","예제에서","예제에서는","예제에서는,","예제와","예제의","예제입니다:","오류","오류!","오류:","오류가","오류를","오버라이드하는","오버라이드해서","오버라이딩","왔는지","외부에서","외부에선","우리","우리는","원할","위","위의","위치에서","위한","위해","위해,","위해서","위해서,","유사하게","유용합니다.","유지하거나","유지하기","유추됩니다.","의미합니다.","이","이것은","이나","이는","이러한","이런","이를","이름을","이미","이번에도","이상을","이용하여","이전","이전과","이전에","이해하기","익숙하다면,","익숙한","인스턴스","인스턴스가","인스턴스는","인스턴스를","인스턴스화","인스턴스화될","인스턴스화하고","인스턴스화할","인터페이스","인터페이스로써","인터페이스를","인터페이스와","일반적인","읽기전용","읽기전용으로","임의로","입니다.","입장에서는","있게","있기","있는","있는지","있다는","있다면,","있도록","있습니다.","있습니다:","있습니다;","있어야","있으며,","있음을","있지만,","자동으로","자세히","자연스러운","자유롭게","자체가","자체를","자체에서","자체의","작동하는지","작동합니다.","작성할","작용합니다.","잘","재사용할","적용되는","적용됩니다.","전에","전역","점만","점을","점입니다.","접근","접근을","접근자","접근자가","접근자는","접근자에","접근하기","접근하는","접근하지","접근할","접두어로","정보를","정의하는데","정의한","정의합니다.","정적","정확하게","제거하고","제공합니다\".","제약","제어할","제외하면","조건이","조금","조정은","존재하는","존재하지","주요","주의해야","줄에서,","중","중요한","즉","지금까지는","지원되지","지원합니다.","지원합니다:","지정자","지정자나","지정자도","지정자를","지향","지향적","직접","짧아진","쪽도","쪽에서","차이를","참조할","처리합니다.","첫","초과한다면,","초기화할","초기화합니다.","초기화해야","초기화했습니다.","최대","추가합니다.","추상","추상으로","추상이","출력하도록","측면과","측면이","컴파일러를","컴파일하여","컴포넌트를","코드","코드는","코드에","클라이언트","클래스","클래스가","클래스는","클래스도","클래스들의","클래스들이","클래스로부터","클래스를","클래스뿐만","클래스에서","클래스의","클래스입니다.","키워드는","키워드를","타입","타입과","타입들","타입들을","타입에","타입으로","타입은","타입을","타입의","타입이","타입인","타입입니다.","통합했습니다.","통해","특성에","특화된","파라미터를","파생","파생되었기","파생된","파생될","파일을","판단되는","패턴","패턴을","편리하지만,","포함하고","포함하는","포함하지","포함할","포함해야","표시된","표시될","표시하는","표시할","프로그래머들에겐","프로그래머들은","프로그래머의","프로그래밍의","프로그램","프로토타입","프로퍼티","프로퍼티,","프로퍼티는","프로퍼티들은","프로퍼티를","프로퍼티에","프로퍼티와","플랫폼에서","필드","필드를","필드에","필드의","필요","필요합니다.","하나는","하며,","하위","하위클래스(subclasses),","하위클래스를","하위클래스에","하위클래스인","하지만","하향","한","한다는","할","할당받을","할당을","할당하고","할당할","할당합니다","함께","함수","함수는","함수라고","함수라는","함수를","함수와","함수의","함수입니다.","합니다.","해주며,","허용하는","현재","형태가","형태의","호출되는","호출하고","호출하여","호출합니다.","호출해야","호환","호환되는지","호환되지","호환된다고","호환될","호환이","혹은","확인하고","확인하기","확인하는","확인할","확장","확장하기","확장할","확장해","후에"],"pages/Functions.html":["\"","\");","\"adams\");","\"adams\",","\"bob","\"bod","\"clubs\",","\"contextu","\"diamonds\",","\"diamonds\"],","\"diamonds\"];","\"hearts\",","\"joseph","\"lucas\",","\"mackinzie\");","\"number\")","\"object\")","\"samuel\",","\"smith\"","\"smith\")","\"spades\",","\"sr.\");","\"this\"","\"will","\"will\",","\"숨겨진","%","'this'를","'화살표","()","(...)","(basevalue:","(e:","(firstname:","(fname:","(function","(function)","(infer","(introduction)","(lastname)","(note:","(option","(overloads)","(rest","(thi","(this:","(type","(typeof","(write","(x:","(그리고",")",")를","*","+","...","...rest:","...restofname:","/","//","10","100;","13","13);","13};","2","4","52);","=","==","=>","?","[\"hearts\",","[{","`this`가","`this`를","adams\"","add(x,","add(x:","addclicklistener(onclick:","addclicklistener가","addclicklistener로","addtoz(x,","alert(\"card:","any는","any입니다.","api를","api에서","arguments라는","array(52),","arrow","buildname(\"bob\");","buildname(\"bob\",","buildname(\"joseph\",","buildname(firstnam","buildname(firstname:","buildname(undefined,","buildname;","buildnamefun:","callbacks)","callee가","card","card:","card;","cardpick","cardpicker();","cardpicker()의","cards:","card를","card와","class","console.log('clicked!');","createcardpicker(this:","createcardpicker:","createcardpicker가","createcardpicker에","deck","deck)","deck):","deck.createcardpicker();","deck:","deck을","deck이","default","e.messag","e.message;","e:","employeenam","es6의","event)","f(this:","firstnam","firstname;","firstname에","firstname을","fucntion","function","function()","function(this:","function(x,","function(x:","function)","function)과","function)로","functions)","h","handler","handler();","handler,","handler의","increment:","info:","interfac","javascript","javascript는","javascript로","javascript에서","javascript에서,","javascript에서는","javascript에서의","javascript에서처럼,","javascript와","javascript의","katz의","lastnam","lastname:","lastname;","lastname?:","lastname을","lastname의","luca","mackinzie\"","math.floor(math.random()","math.floor(pickedcard","math.floor(x","mode에서는","myadd","myadd:","myadd는","mydeck","mydeck[pickcard(mydeck)];","new","noimplicitthi","note:","null","number","number)","number):","number,","number;","number[];","onclickbad(this:","onclickbad가","onclickgood","onclickgood(this:","onclickgood이","onclick이","paramet","parameter)","parameters)","pickcard","pickcard(15);","pickcard(x):","pickcard(x:","pickcard가","pickcard를","pickedcard","pickedcard.card","pickedcard.suit);","pickedcard1","pickedcard1.card","pickedcard1.suit);","pickedcard2","pickedcard2.card","pickedcard2.suit);","pickedcard;","pickedsuit","restofname.join(\"","result1","result2","result3","result4","return","samuel","smith\"","strict","string","string)","string,","string;","string[])","string[];","suit","suit:","suits:","suits[pickedsuit],","this.info","this.info까지","this.info를","this.suits[pickedsuit]","this.suits[pickedsuit],","this.suits[pickedsuit]의","this:","this가","this는","this로","this를","this와","this의","this타입을","type)","types)","typescript","typescript는","typescript를","typescript에는","typescript에서는","typescript에서도","typing\"","uielement","uielement.addclicklistener(h.onclickbad);","uielement.addclicklistener(h.onclickgood);","undefin","undefined);","undefined가","undefined로","undefined를","void","void)","void):","void,","void;","void는","void로","void를","void일","window","window로","window에","x","x.length);","y","y)","y:","y;","yehuda","yehuda의","y는","z","z;","{","{suit:","}","},","};","}[]):","}];","가","가능하므로","가독성을","가장","가정합니다.","가지","가지고","가집니다","가집니다:","가짜","각","간에","간주합니다.","감지합니다.","값은","값을","강력하고","강요되지","갖는","개발자들","객체","객체가","객체들을","객체를","객체마다","객체에서","객체인지","걸","검사","검사를","검사합니다.","겁니다:","것","것부터","것에","것으로","것은","것을","것이","것이지만,","것인지를","것입니까?","것입니다.","것입니다:","결과를","경고를","경보","경우를","경우를,","계속해서","계층을","고치기","곳이","공유됩니다.","공유함을","공유합니다.","공통된","공통성을","구성","구성하지","구성합니다.","구체적인","구축하거나","구현할","구현해","그","그냥","그대로","그들은","그래서","그러면","그렇게","그렇다면,","그렇지","그룹","글","글은","기능을","기능이지만","기대하는","기대했던","기명","기본","기본값은","기본만","기본적인","기술들로","기술을","끝에","나머지","나열되어","나오는","나중에","남깁니다.","내부","내부에","내부의","너무","넘겨","넘겨주지","넘겨줄","넘겨지는데","넘길","넘어가겠습니다.","네임스페이스,","노력을","높습니다.","놓을","는","다룰","다르게","다른","다수의","다시","다중","다행히도","단점입니다.","당신이","대답해","대신","대한","대해","더해보겠습니다.","데","독립형","동일한","동작","동작,","동작을","동작하는지","동적인","됐습니다.","된","된다면","될","될것입니다.","됩니다.","두","둔다면","둘","뒤따르는","뒤에","뒤의","들어보겠습니다:","따라","따라서","따릅니다.","때","때,","때는","때도","때로는","때를","때문에","때문입니다.","때에","때의","또는","또한,","라고","라는","라이브러리","라이브러리는","라이브러리에","런타임에서","레벨에서의","를","리스팅을","리터럴","마찬가지로","막는데","만들","만약","만큼","많은","매개변수","매개변수가","매개변수는","매개변수든","매개변수들의","매개변수들이","매개변수라고","매개변수라는","매개변수로","매개변수를","매개변수만을","매개변수보다","매개변수에","매개변수와","매개변수와는","매개변수의","매개변수입니다.","매우","먼저","메서드","메서드들은","메커니즘이","명시적으로","명시해","명확하고","몇","모듈에","모듈이","모든","모를","모방,","모을","목록에","목록에서","목록으로","목록은","목록을","목록처럼","무언가라면","무엇인지","무한으로","문법의","문을","문제가","문제는","물론,","및","바꿀","바꿔줍니다:","바르게","바인딩을","반드시","반면,","반영되지","반환","반환될","반환하거나","반환하기","반환하는","반환하지","받는","받는것","발견하는","발생할","발생합니다.","방법대로라면","방법에","방법을","방정식의","배열","배열을","배울","번에","번째","번째로","번째로,","벗어나는","변경해야","변수는","변수로","변수를","변수입니다.","변화를","보겠습니다.","보겠습니다:","보고","본문의","본질적으로","볼","봅시다.","봅시다:","부릅니다.","부분입니다,","부호","부호는","분명히","불행히도","붙습니다.","붙였으니,","붙이더라도","붙임으로써","비","비슷한","비워두는","빌드하여","빠르게","사라지고","사실만","사실상","사용","사용됩니다:","사용을","사용자가","사용자는","사용하기","사용하는","사용하여","사용할","사용해","사용해야","사용했던","사이에","살펴보고","상관없이","상위","상태\"의","상태에서","새로운","생각하면","생긴","생깁니다.","생략","생략할","생성된","선택적","선택적,","선택적으로","선택적이고,","선택하면","선택하여","선택한","선택할","선택합니다.","설명하는","설명하므로,","설정되었기","성공,","성을","소개","수","수고가","수는","수도","수를","수와","수월하게","수행합니다.","순서를","순수한","숫자를","쉽게","승인하고","시도합니다.","시스템에서","실수를","실행되는","싶다면","써서","쓰면","쓰이는군요.","쓰이는지","쓰일","쓸","아는","아니라","아닌","아닙니다.","아래","아랫줄은","아무것도","아주","악명","않거나","않는","않는다는","않는다면","않다면","않습니다.","않을","않음을","알게","알고","알맞게","알맞은","알아낼","알아야","알아채셨나요?","앞서","앞에","애플리케이션에","애플리케이션에서의","어느","어떤","어떻게","언급했듯이,","언어입니다.","얼마나","없는","없다는","없습니다!","없습니다.","여기","여기서","여기서는","여러분의","여전히","역시","역할을","예상하는","예시로","예시를","예시에","예시에서","예제를","예제에서","오게","오는","오류!","오류,","오류가","오류도","오류를","오버로드","오버로드는","오버로드로","오버로드를","오버로드만을","오직","올바르게","와","왔기","외부의","요구하지","요소입니다.","요약하자면,","원본","원하거나,","원하는","원한다면","위","위의","위치한","위한","위해","위해,","위해서,","유연한","유의하세요,","유일한","유저가","유지하기","유효한","은","은닉,","을","의","의미하기도","의미하는","의미합니다,","의미합니다.","의해","이","이것은","이것을","이것이","이곳에서","이나","이는","이라","이러한","이런","이런,","이렇게","이를","이름","이름과","이름으로","이름은","이름을","이야기합니다.","이유로","이전","이전에","이제","이해는","이해하기","이해하는","익명","인스턴스로써","인자","인자가","인자들을","인자로","인자를","인자의","인터페이스","일반","일반적입니다.","일부","일부이고","일으키겠군요","일으키지","일을","일입니다.","일종의","일치하게","일치해야","일회성","읽도록","입력해보세요.","있기","있는","있다는","있다면","있더라도","있도록","있습니다.","있습니다:","있습니다;","있어","있으므로","있을","있지만,","자기","자신을","자신의","자체적인","작동시키면","작동하는지","작동하는지에","작성되어","작성된다는","작성자는","작성하고자","작성하기","작성하는","작성하든","작성해","작업에서는","작업은","작업을","작업하기를","작업할","잘","잘못","잘못된","잡아낼","장단점)를","재사용하기","적용한","적은","적합하다고","적합한","적합합니다.","전달된","전달될","전달에","전달하는","전달하든","전달한다면","전달할","전달해","전에","전체","점이","정답은","정보","정의가","정해","정해줄","정해지는","정확함","제공된","제공하는","제공하지","제공합니다.","제공했는지를","주목해","주세요.","주어야","주어지고","주어진","주제를","줄","줄일","줍니다.","줍시다.","중요합니다.","중인","지금은","지어","지정하고","지정합니다.","지정해","직접","진행하면서","집합이므로","짚고","쪽의","참고로,","참조할","창","처리되며,","첫","초기화","초기화를","최상위","최종적으로","추가합니다.","추가해","추론","추상화","충돌을","취급합니다.","취할지","카드가","카드를","캡처(capture)","캡처된","캡처할","캡처합니다:","컴파일러가","컴파일러는","컴파일러에","코드","코드를","콘텍스트에","콜백","콜백에서","콜백을","클래스","클래스,","타이핑","타입","타입과","타입들과","타입들을","타입들이","타입만이","타입에","타입에도","타입에서","타입으로","타입은","타입을","타입의","타입이","타입이기","타입이며","타입이어야","타입인","타입입니다.","통과의례입니다.","통해","통해,","특히","파라미터와","파악할","표기'(","표기에","표시를","표시할","표시합니다.","표준","표현식을","프로그램에서","프로세스를","프로토타입에","플래그가","플래그를","필수","필수,","필요가","필요로","필요하다고","필요한","필요합니다.","하게","하고","하기","하나.","하나만","하나와","하나의","하는","하도록","하지만","한","한다고","한다는","한다면","한쪽에만","할","할당될","함수","함수(anonym","함수(name","함수가","함수는","함수로","함수로써,","함수를","함수에","함수에서","함수의","함수임을","함수처럼","함을","합니다","합니다.","항상","해결할","해당","해당되지","해주어야","핵심","했을","형태를","형태에","호출","호출과","호출되어야","호출된다는","호출될","호출들을","호출은","호출을","호출하는","호출하려고","호출하므로","호출할","혼란스러움은","화살표","확실한","확인","확인함","흔한"],"pages/Generics.html":["\"\";","\"a\");","\"hello","\"m\");","\"mystring\"를","\"test\"));","\"제너릭","'a'","'b'","'c'","'d'에","'m'","'string'입니다.","()","(arg:","(gener","(hello","(introduction)","(use","(work","(x:","(여기서는","(예","(즉,","+",".length",".length가",".length를",".length에","//","//출력","0;","1,","10,","2,","3,","3});","4","<>로","=","=>","a):","a:","add:","anim","any):","any나","any를","any와","api뿐만","arg;","arg가","arg를","arg의","array","array):","array와","b:","bee","beekeep","beekeeper;","boolean;","c#과","c();","c:","class","classes)","console.log(arg.length);","console.log(stringnumeric.add(stringnumeric.zerovalue,","constraints)","create(c:","createinstance(bee).keeper.hasmask;","createinstance(c:","createinstance(lion).keeper.nametag;","d:","dictionari","dictionary).","echo","extend","function","function(x,","gener","genericidentityfn","genericnumb","genericnumber();","generics)","getproperty(obj:","getproperty(x,","hasmask:","hello","ident","identity(\"mystring\");","identity(arg:","identity;","identity를","identity와","interfac","java","k)","keeper:","key:","length:","lengthwis","lion","loggingident","loggingidentity(3);","loggingidentity(arg:","loggingidentity({length:","loggingidentity는","loggingidentity의","mygenericnumb","mygenericnumber.add","mygenericnumber.zerovalu","myidentity:","nametag:","new","number","number),","number).","number):","number;","number는","number를","number에","numlegs:","obj[key];","obj에","output","paramet","prototyp","return","string;","stringnumer","stringnumeric.add","stringnumeric.zerovalu","string으로","string이나","t","t)","t):","t,","t;","t[]","t[]):","type","types)","typescript에서","t가","t는","t라는","t를","t에는","t와","t의","u","u)","value:","variables)","world","world\"인","x","y)","y:","y;","zerovalue:","zookeep","zookeeper;","{","{new():","|","}","}):","};","가","가능한","가능합니다.","가독성","가장","가정해봅시다.","가져오고","가져오지","가져옵니다:","가지","가지고","가진","가짐을","가집니다.","가집니다:","간결하고","감싸주었습니다.","값을","값이","값인","강요합니다.","같은","객체","객체를","객체에서","거대한","겁니다:","것","것과는","것도","것보다","것으로","것은","것을","것이","것입니다.","것입니다:","것입니다만,","것처럼","경고합니다.","경우를","경우엔","고급","고유한","곳에서도","관계를","굉장한","구성하는","구축하는","그것의","그대로","그렇게","기술할","기억하십시오.","기억한다면","길이를","꺾쇠괄호(<>)","꺾쇠괄호(<>)에","나","나면,","나열되는,","나열해야","나중에","낼","넘기면","넘긴다고","넣으면","넣을","네임스페이스는","능력을","다루도록","다룰","다뤘던","다르게","다른","다시","다양한","다음","단일","담아","대신","대신에","대신에,","대체할","대한","대해","대해서는","더","데","데이터","데이터와","도구","도구상자의","도움이","동일한","동작하는","동작하도록","동작하므로","동작하지","되므로","될","됩니다.","두","두었습니다.","뒤에","들면:","들어","따라","따라서","때","때,","때를","때문에","때와","때의","또는","또한","로그에","를","리터럴","리터럴을","마찬가지로","만드는","만들","만들고","만들었습니다.","만듭니다.","만약","매개변수","매개변수가","매개변수들은","매개변수로","매개변수를","매개변수에","먼저","멤버","멤버가","멤버는","명령과","명시되어","명시적으로","명시적인","명시하는","명시합니다:","명시해","모두를","모든","모릅니다.","목록을","무엇이","문자","미래의","바로","바인딩","반환","반환되는지","반환된다는","반환하는","반환한다.\"라고","반환할","받을","발생하지","방법","방법에","방법은","방법이","방법입니다.","방식에","배열로","배열에서","배열은","배열을","배열인","버전의","번째","변수","변수가","변수를","변수의","변화가","보고","복잡한","본","본문에","볼","봅시다.","부분을","부분입니다.","불문하고","비","비슷하게","비슷한","비슷합니다.","뿐입니다.","사용","사용되는","사용자는","사용하고","사용하기","사용하는","사용하여","사용하지만","사용한","사용할","사용합니다","사용합니다.","사이의","살펴보겠습니다.","살펴보도록","생각할","생성자","생성하는","생성하였고,","생성할","선언과","선언할","설명하는","성공","섹션에서","섹션에서는","소개","소프트웨어","수","수도","수와","스타일이","시그니처가","시그니처로","시그니처를","시그니처에","시마다","시스템을","시작하면,","실수로","실제로","싶습니다.","싶은","싶을","싶을지도","쓰고","쓰는","쓰도록","쓸","아닌","아마","아주","안쪽에","않는","않도록","않습니다)","않습니다.","않습니다:","않은","않음.","알기","앞서","앞에서","앞쪽의","어떤","어떻게","언어들과","언어에서,","얻게","얻을","없는","없다면,","없습니다.","없으므로","엔지니어링에서의","여기","여기서","여기서는","여기에서는","여러","열거형과","예로","예를","예제를","예제에","예제에서","예제에서,","예제에서는","예제의","오던","오류,","오류:","오류가","오류는","오류를","옮기고","외에도","우리가","우리는","우리의","운반할","원했지만,","위","위해","유사하게","유연한","유연함을","유용하지만","유저가","유추하고","유추할","은","을","의도했다고","의미한다고","이","이것들로","이것은","이것을","이러한","이런","이렇게","이렇게도","이를","이름","이름을","이름이","이미","이번","이상","이용해","이전","이전에","이제","이해하는","익숙할","인수","인수가","인수로","인수를","인수에","인수와","인수의","인스턴스","인터페이스","인터페이스는","인터페이스로","인터페이스를","인터페이스와","인터페이스의","일관된","일단","일반적인","일부인","읽을","잃게","잃지","있게","있게끔","있기","있는","있는지에","있다는","있습니다","있습니다.","있습니다:","있어","있어야","있었습니다.","있지","자동으로","자신만의","자체에","자체의","작동하는","작성하고","작성하는","작성할","작업","작업할","작은","잘","재사용","적용되는","전달이","전달하는","전달할","전달해","전달해야","전체","점에서","접근하기를","정보는","정보도","정보를","정보만","정의되고","정적","정하게","정합니다.","정확합니다.","제공할","제공합니다.","제네릭","제네릭에서","제네릭을","제네릭의","제네릭이","제네릭이라","제네릭이므로","제네릭이지만,","제네릭입니다,","제약","제약사항을","제약조건","제약조건에서","제약조건을","제약조건이","제한되어","제한된","제한하고","제한하는","제한할","제한합니다.","조건을","존재하지","주고","주목하세요;","주변에","주어야","주요","주요한","주지","준","중","즉,","증명할","찍으려면","참조해야","첫","초월한","최소한","추가했습니다.","추론","추론은","출력","취급할","취하고","측면.","측면과","측면에서만","측면이","캡처하고","캡처할","컴파일러가","컴파일러는","컴포넌트나","컴포넌트는","컴포넌트를","코드를","클래스","클래스는","클래스로","클래스를","클래스에서","클래스와","클래스의","키워드로","타입","타입검사!","타입과","타입들로만","타입들에서","타입들의","타입만","타입변수","타입변수를","타입에","타입에서","타입으로","타입으로써","타입은","타입을","타입의","타입이","타입이든","타입인지에","타입화된","통해","특정","특정한","팩토리를","포함한","표시하기","표현한","표현할","프로퍼티","프로퍼티가","프로퍼티들이","프로퍼티를","필요한","필요할","필요합니다","필요합니다.","하겠습니다.","하기","하나는","하나로","하나로써","하나의","하는","하려면","하면","하면,","한","한쪽에서","한쪽으로","할","함수","함수가","함수는","함수로","함수를","함수만큼","함수에","함수와","함수의","함수입니다.","합니까?","합니다.","합니다:","해당되지","해도","해봅시다.","해야","했던","허용하지만,","현재의","형태가","호출","호출할","확인할","효과적으로","훨씬"],"pages/Enums.html":["!==","\"a\"","\"a\";","\"bar,","\"baz\")","\"down\",","\"foo\",","\"left\",","\"right\",","\"up\",","\"yes\",","\"직렬화\"를","%,","&,","'debug';","'e1'","'e2'","'error'","'info'","'shapekind.circle'","'shapekind.square'","'warn'","(ambient","(comput","(const","(const가","(e.g.","(enum","(enum)","(enums)","(function","(heterogen","(name","(num","(numer","(revers","(string","(union","(valu","(x","(기본적으로","(다른","(아래","(역","(예시.","*","*,","*/","*/,","*/];","+,",",","...","/*","/**","/,","//","0,","0]","0으로","1","1,","100)","100,","1씩","2","2,","3","3,","4",":","=",">",">>,",">>>,","[0","[directions.up,","^","ambient","a가","b","b,","bar","bar,","body가","booleanlikeheterogeneousenum","c","c:","caroline\",","circl","circle,","compil","const","constant","debug","declar","direct","direction.up","directions.down,","directions.left,","directions.right]","down","down,","e","e)","e.bar","e.bar)","e.foo","e.x는","e1","e2","enum","enum.a;","enum;","enum[a];","enum[enum[\"a\"]","enums)","error,","e가","f(e);","f(obj:","f(x:","fileaccess","foo,","function","getsomevalue(),","infin","info,","interfac","javascript","keyof","kind:","left","left,","loglevel","loglevel;","loglevel[key];","loglevelstr","loglevelstrings,","mappings)","member","members)","message:","name)","nameofa","nan","none,","num","number","number;","obj.x;","printimportant(key:","radius:","read","respond(\"princess","respond(recipient:","respons","response):","response.yes)","return","right","right,","runtime)","shapekind","shapekind.circle;","shapekind.square,","shapekind.square;","sidelength:","squar","square,","string)","string,","time)","true","true를","type","typeof","types)","typescript","typescript는","up","up,","up이","value)","var","void","warn,","x","x,","x:","x가","x라는","y,","ye","z","{","{}));","|","|,","||","}","})","})(enum","~","~~~~~~~~~~~","가","가능합니다.","가장","가져옵니다.","가지게","가지고","가지면","가진","가집니다.","각","각각의","간단합니다:","간단히","간접","간주하는","간주할","간주합니다.","간주합니다:","값","값과","값들로","값만","값에","값에서","값으로","값은","값을","값의","값이","값일","갖습니다.","같은","같이","개념이지만","객체라고","객체로","객체를","객체에서","객체입니다.","겁니다.","것","것과","것으로","것은","것을","것이","것입니다.","경우","경우,","경우.","경우가","경우에","계산되지","계산된","공간에","과","과정에서","괄호로","구별돼야","구분되는","굳이","권장합니다.","그","그냥","그러나","그렇게","기능은","기대하는","기반","기술적으로","나오거나,","나오는","나온","나타내는","납니다.","노출되며","느끼실","는","다르게","다른","다릅니다.","다시","단항","달리","당신이","대부분의","대신,","대한","대해서","더","더는","데이터이며","도움이","동일합니다.","동작과","동작은","동작이","동작하는","동작합니다.","된다는","될지라도","됩니다.","두","둘","뒤따르는","뒤에","들어","들어:","디버깅하고","따라","때,","때문에","때문에,","때문입니다.","또","또는","라면,","런타임에","런타임에서","로","를","리터럴","리터럴)","리터럴에","만들수","만약","말입니다),","말해,","말해서","매핑","매핑과","매핑을","먼저","멤버","멤버가","멤버는","멤버도","멤버들은","멤버로","멤버를","멤버에","멤버와","멤버의","멤버이므로","멤버입니다.","명심하시길","모두","모든","모습을","묘사하기","무관하게","묶인","문서화","문자","문자를","문자열","문자열로","묻는","및","바랍니다.","반드시","반면","반환합니다.","받습니다.","방식은","배우진","배워","배워보겠습니다.","버그를","번째","보신","부분","분들이라면","불확실한","붙여","비","비교하는","비용을","사례","사실을","사용될","사용됩니다.","사용하는","사용하면","사용하지","사용한","사용할","사용해","상수","상수들의","상수로","상수이거나","상수입니다.","상수입니다:","생성된","생성하는","생성하지","섞어서","선언합니다.","선언했습니다.","설명된","수","수도","숫자","숫자만으로는","숫자와","쉽게","시","시스템이","시작될","시점에","시점에서","신경","실제","실제로","실행될","실행할","쓰이게","쓰지","아니라면,","아닌)","아닌지","아래","아래와","아래의","아직","않거나,","않기","않는","않는다","않는다면,","않습니다.","않습니다:","않았지만,","않은","않을","않지만,","알고","알아낼","알아두면","앞에","약간","어떤","어리석은","언어를","엄격해","없는","없습니다.","없으며","없으므로","없지만,","에러!","역","역방향","연산자","열거","열거형","열거형과","열거형에","열거형에서","열거형으로","열거형은","열거형을","열거형의","열거형이","열거형처럼","예를","예제에서","예제에서:","오류!","오류가","오직","와야","완벽하게","완전히","외에도","요구사항이","우리는","원한다면,","위","위해","유니언","유니언이","유사한","유용합니다.","유의미하고","유의미한","유효한","은","을","의","의도를","의미로","의미인지","이","이거나","이것은","이것이","이기","이러한","이렇게","이름과는","이름으로","이름을","이름이","이면","이미","이외","이용하면","이용하여","이용해서","이유는","이전에","이점이","이종","이중","이후에","인라인되지","인라인됩니다.","일반적인","일부입니다.","읽기","읽어야","있고","있기","있는","있다는","있다면,","있습니다","있습니다!","있습니다.","있습니다:","있으며","있음)","있지","있지만","자동","자동으로","자체가","자체에","자체에는","자체에서","잘못","잘한다는","잡을","장점을","저장하는","적용된","적절하지","전달될","전부","점만","점은","점입니다.","접근으로","접근하며,","접근할","정방향","정보를","정의된","정의할","정의합니다.","정확한","제거됩니다.","제공합니다.","제공해주지","조건과","조건은","조건이","존재하는","존재하지","좀","종종","좋은","중","즉","증가된","증가하는","증가한","지점부터","지정된","지정자를","집니다.","집합을","집합이","차이점은,","참조","참조)를","참조는","참조에","첫","첫째로","체크할","초기화","초기화가","초기화되는","초기화되지","초기화된","초기화됩니다.","추가로","추가적인","취하려는","친숙하게","컴파일","컴파일됩니다.","컴파일할","코드","코드는","코드로","코드를","코드에서","코드에서,","코드입니다.","큰","키를","키워드는","키워드를","타입","타입에","타입은","타입을","타입의","타입처럼","통과되지","특별한","특수한","특정","표현식","표현식만","표현식에","표현식으로","표현식은","표현식을","표현식의","표현식이라고","프로퍼티","프로퍼티로","프로퍼티를","피연산자로","피하기","필요가","필요합니다.","하거나","하나이기","하는","하지","하지만","한다면,","할","할당됩니다.","할당할","할지라도,","함께","함수로","합니다.","합니다:","항상","해결책입니다.","해야","허용되지","혹은","확실하게","확인합니다.","활용할","효율적으로"],"pages/Type Inference.html":["\"다른","\"문맥상","\"최적","(","(basic)","(best","(contextu","(introduction)","(rhino","/","//","1,","3;","4가지","=","[0,","[new","anim","animal,","animal[]","animal을","animal이","any)","button","common","console.log(mouseevent.button);","console.log(uievent.button);","const","createzoo():","eleph","elephant(),","elephant,","function","function(mouseevent)","function(uievent)","function(uievent:","handler","kangaroo","mouseev","mouseevent가","new","noimplicitani","null];","null입니다.","number로","number와","return","rhino(),","rhino,","snake()];","snake)[]과","snake.","type)","typescript","typescript가","typescript는","typescript에서는","typescript의","typing)","uievent","uievent가","uievent는","undefined을","window.onmousedown","window.onscrol","window.onscroll에","x","zoo","zoo:","{","|","}","가지","가지며","가집니다:","각","같은","객체","객체가","객체에는","검사는","결과는","결정할","경우","경우,","경우에","계산합니다.","고려하여","고려해야","고를","공통","기반으로,","기본","기본값를","다루겠습니다.","다른","단언,","대부분의","대해","더","두","들면:","들어,","들어:","따라","때","때,","때문에","때문에,","리터럴의","만약","많은","매개변수의","멤버,","멤버를","모든","문맥상","문맥에서도","문맥적으로","반환","반환문이","발생시킵니다.","발생할","발생합니다.","방법에","방향\"에서도","배열","배열의","변수","변수가","변수와","별도의","보고하지","사실을","사용됩니다.","사용하여","사용하지","상위","선택됩니다.","선택하기","선택할","선택합니다.","설정하며,","소개","수","아닌","않는","않는다면)","않습니다.","않으면","알고","알고리즘에","알고리즘은","알아보겠습니다.","암묵적으로","암시될","어디에서,","어떻게","없기","없는","없습니다.","없어서","없음을","여기서","여기에서","여러","예를","예제에서","예제의","오류를","오른쪽,","오른쪽에","옵션을","요소","요소들의","우리는","원하지만,","위","위치에","위해","위해서는","유니언","의","의해","이","이들","이라고","이러한","이렇게","이를","이번","이상적으로는","이야기해보겠습니다.","이전","인수","인수,","인수는","일반적인","임을","있는","있다는","있다면,","있습니다.","있습니다:","있지만,","자세히","잘해냅니다.","장에서는","재정의할","적용됩니다.","정보를","제공하기","존재하지","존재해도","좀","중","중,","즉","직관적입니다.","초기화하고,","최적","추론","추론되길","추론되는지","추론되지","추론됩니다.","추론은","추론을","추론의","추론이","추론하는","추론하려면","추론하지","추론할","추론합니다.","출력합니다.","코드는","코드에서","타이핑","타이핑\"","타이핑은","타입","타입\"을","타입들로부터","타입으로","타입으로도","타입은","타입을","타입의","타입이","타입입니다.","포함하는","포함할","표기가","표기하여","표기해야","표현식에서","표현식의","프로퍼티가","프로퍼티는","하지만","할당","할당되어","할당의","함수","함수가","함수의","합니다.","해결하기","해당","했을","호출","후보","후보가"],"pages/Type Compatibility.html":["\"","\",","\",\"","\"alice\",","\"alice\"});","\"seattle\"","\"seattle\"});","\"건전\"하지","\"아마도\"","\"호환\"","'args'를","'버리는'","((e:","()","(...args:","(a","(a:","(advanc","(b:","(classes)","(compar","(e","(e:","(enums)","(function","(generics)","(introduction)","(n:","(option","(privat","(start","(subtyp","(x,","(x:","(x?,","(x와","(y:","({name:","(명확한","(타입","(프로그래머에게는)","*/","+","...","/*","//","0;","2,","2],","3","3];","=","=>","[1,","a:","a;","anim","animal;","any)","any[])","any[],","any는","any로","any에서의","any와","array#foreach는","array)","assignment)","bivari","bivariance)","blue,","c#이나","callback:","class","classes)","color","color.green;","console.log(\"hello,","console.log((","console.log(e));","console.log(e.x","console.log(item));","console.log(x","constructor(name:","constructor(numfeet:","data:","e.y))","e.y));","empti","empty;","empty를","enum","enum과","event","event)","eventtyp","eventtype,","extend","extends의","feet:","function","function(x:","function(y:","functions)","green","greet(n:","greet(y);","handler:","ident","implements와","index,","interfac","invokelater([1,","invokelater(args:","invokelater는","item","items.foreach((item,","items.foreach(item","javascript","javascript는","javascript에서","javascript에선","java와","keyboard","keycode:","keyev","listenevent(eventtype.mouse,","listenevent(eventtype:","locat","location:","member","mouse,","mouseev","mouseevent)","mouseevent).x","mouseevent).y));","n.name);","name","name:","named)","named)만","named;","name이라는","new","note","notempti","notempty;","number","number)","number,","number;","numfeet:","out)","overloads)","p","p:","paramet","parameters)","person","person();","privat","private과","protect","ready,","red,","rest","revers","reverse;","s","s:","s;","safety)","size","size;","soundness)","statu","status.ready;","strictfunctiontypes을","string)","string,","string;","t","t):","t;","timestamp:","topics)","two","typescript","typescript는","typescript에서","typescript에서는","typescript의","typing)","u","u):","undefined를","void)","void);","vs","wait","x","x()는","x:","x;","x를","x에","x와","x의","y","y)","y));","y:","y;","y?)","y가","y는","y를","y에","y에서","y의","{","}","};","가능하거나","가능하지만","가능한","가져야","가지","가지고","가지므로","가진","가진다는","각","간단하지만,","간단한","간주됩니다.","값은","값의","강제로","갖고","같은","개수의","개의","객체","객체를","건전성","건전성에","건전하지","검사를","검사하기","검사하여","검사한다는","검사할","검사합니다.","것으로","것은","것이","것입니다.","결과","결정됩니다.","경우","경우,","경우는","경우에는","경우에도","경우와","계층","고급","고려됩니다.","고려하지","고려했으며,","곳과","곳을","과는","과정은","관계시키는","관계의","관점에서는","관해선,","광범위하게","괜찮습니다!","구조가","구조와","구조의","구조적","구현체로","궁금할","규칙은","규칙을","규칙이","그","그러므로","그럼에도","그리고","기반으로","기본","기술하지","나머지","내용은","는","다르게","다른","다릅니다.","다음","다음을","대부분","대상","대신해서","대안","대응하기","대조적입니다.","대한","대해","더","덜","동일","동일한","동작하는","동작합니다.","동작합니다:","되도록","되지","두","드물지만","들면,","들어,","들어:","따라","따라서","때","때,","때는","때문","때문에","때문에,","때문입니다.","또한","똑같이","런타임","리터럴","마세요.","마찬가지로","마치","많은","말합니다.","매개변수","매개변수가","매개변수는","매개변수도","매개변수를","매개변수만","매개변수에","매개변수와","매개변수의","매개변수인","매개변수처럼","매우","먼저","메커니즘","멤버","멤버(이","멤버가","멤버는","멤버를","멤버만","멤버만으로","멤버에","멤버와","멤버의","명목적","명시적인","모든","목록에서만","목록을","목적을","못한","무시하는","무한한","문서","문자열","바꿔","바람직하지","바람직하진","반대여도","반환","받아서","발견되는","발견할","발생시키지","발생시킵니다.","발생하는","발생하도록","발생하면","발생합니다.","방식에","방식입니다.","배열","배열을","번째","복잡합니다.","부분을","불구하고","비","비교","비교됩니다.","비교적","비교하는","비교할","비롯된","사양에","사양을","사용하기","사용하는","사용하여","사용하지","사용할","사용합니다.","사용했습니다.","살펴보겠습니다:","살펴봅니다.","살펴봅시다:","상속","상위","상응하는","상황에","상황에서","상황이","생성된","생성자는","서로","서브","선택적","설계되었습니다.","설명합니다.","성공","성공,","성공합니다.","소개","수","수도","수행할","숫자","숫자는","숫자와","시간에","시그니처와","시나리오에","시스템","시스템보다는","시스템은","시스템을","시스템의","시스템이","시스템이)","시스템이기","시작하기","식으로,","신중하게","실용적인","실제로","심지어","아니고,","아닌","아닙니다.","아이디어는","안전성(type","안전하게","않고","않기","않는","않다고","않습니다.","않아","않았기","않은","않음","않지만","않지만,","알","어떤","어떻게","언어","언어에서","언어에서는","없는","없습니다.","없음","에를","여러개의","여전히","열거형","열거형과","열거형은","영향을","예를","예외를","예제:","예제는","예제를","예제에","예제에서처럼","예측이","오류","오류).","오류,","오류가","오류는","오류를","오버로드","오버로드가","오버로드는","오직","완전히","요소,","요소의","용어가","원본","원시","위에서","위치는","위치에","위해","위해,","유발하는","유사하게","유용하고","유용합니다:","유의하세요.","유의합니다.","유형의","을","의해","이","이것은","이것을","이는","이러한","이런","이를","이름은","이용하여","이유가","이유는","익명","인덱스","인수가","인수를","인스턴스","인스턴스도","인스턴스의","인터페이스를","인터페이스와","일련의","일반적이기","일반적인","일반적임","일부로","일치해야","입니다.","있게","있기","있는","있는지","있는지에","있다면","있다면,","있습니다.","있습니다:","있어야","있을","있지만","있지만,","자세한","자연스럽습니다.","작성","작업을","재귀적으로","적용되는","적용되지","적용됩니다.","적용됩니다:","전달하는","전체에서","점만","점에","정의된","정적","정적인","제공하는","제공할","제공합니다","제공합니다.","제네릭","제대로","제외하곤","조금","종류의","주제","주지","줍니다.","중","지금까지","지정되지","지정된","지정함으로써","진행됩니다.","질문은","참고사항","참고하세요.","찾습니다.","처리되는지","처리됩니다.","첫","최소한","추가","추가적으로","추가하여","추론된","취하여","측면에서","측에서","컴파일","컴파일러","컴파일러는","코드는","코드를","코드의","콜백","콜백을","클래스","클래스는","클래스에서","클래스와","클래스와는","클래스의","타이핑(nomin","타이핑(subtyping)을","타이핑이기","타이핑이란","타입","타입과","타입만","타입에","타입에만","타입은","타입을","타입의","타입이","타입처럼","탐색하면서","통해","특성을","특수한","특수화된","특정","패턴들을","패턴입니다:","포함하는","표현식이나","표현하는","프로퍼티가","프로퍼티를","플래그인","필수","필수적인","필요함)","하나를","하위","한","할","할당","할당.","할당과","할당은","할당을","할당이","할당할","함수","함수가","함수들이","함수를","함수에","함수에게","함수와","함수의","합니다.","해당","해당하므로","허용되는","허용되지","허용됩니다.","허용하는","형태를","호출","호출하는","호출한","호출할","호출함","호환","호환되며","호환되지","호환된다는","호환될","호환됩니다.","호환성","호환성에","호환성은","호환성을","호환성이","호환이","혼란스럽고","확인할","확장하여","훨씬"],"pages/Advanced Types.html":["!==","!를","\"","\")","\");","\"a\"","\"b\"","\"bar\";","\"bob\";","\"boolean\"","\"c\"","\"circle\":","\"circle\";","\"d\"","\"default\";","\"eas","\"false\"","\"foo\";","\"function\"","\"id\"","\"img\"):","\"input\"):","\"name\"","\"number\"","\"number\")","\"number\",","\"number\";","\"number\"를","\"object\"","\"object\";","\"padding\"을","\"rectangle\":","\"rectangle\";","\"square\":","\"square\";","\"string\"","\"string\")","\"string\",","\"string\";","\"subparts\"","\"symbol\"이여야","\"triangle\"의","\"true\"","\"typename\"","\"typename\"이","\"undefined\"","\"uneasy\");","\"uneasy\"는","\"updatepart\"","\"리터럴","\"싱글톤","${name}.`);","&","'","'!=='","'\"eas","'\"uneasy\"'","'${padding}'.`);","'.","'1'과","'2'","'camry',","'dictionary'에","'fly'에","'foo'는","'manufacturer'","'manufacturer');","'model'","'model']);","'name'은","'null'은","'number","'number'에","'number'이어야","'option1'","'option2';","'ownersaddress'로","'padding'은","'padding'이","'string","'string'","'string'에","'swim'과","'toyota',","'u","'undefined'는","'unknown');","'unknown']);","'unknown'은","'unknown'이","'year'","'year');","'year')의","'year'])","'year'에","'year'와","(\"swim\"","('manufacturer'","(()","((pet","()","(...args:","(a","(b","(billion","(c","(co","(condit","(const","(constraint)","(discrimin","(distribut","(eas","(enum","(exhaust","(first.hasownproperty(prop))","(homomorphic)","(index","(infer","(instanceof","(interfac","(intersect","(isfish(pet))","(isnumber(padding))","(isstring(padding))","(javascript에는","(map","(naked)","(nullabl","(numer","(object['42'])나","(object[42])를","(option","(pet","(pet.fly)","(pet.swim)","(polymorph","(predefin","(result","(s.kind)","(second.hasownproperty(prop))","(sn","(string","(tabl","(type","(typeof","(union","(use","(user","(x","(x:","(y","(|)로","(그냥","(다른","(오버로딩된","(이는","(즉","(즉시","*","**","**마세요**!","*/","*=","+","+=","..","...",".add(1)",".currentvalue();",".multiply(5)",".sin()","/","/**","//","0)","0);","0,","0;","1","1).join(\"","1,","12;","13;","1이어야","2","2)","2);","2.7","2.8에서","2014","2;","2와","3","3.7","3개의","4","4);","5","6",":","=","==","===","=>","?","['manufacturer',","['model',","['year',","[k","[key:","[p","a:","a;","add(operand:","age:","age?:","alia","alias):","alias;","aliased(arg:","aliased는","aliases)","anim","animate(dx:","any)","any):","any;","any[]","any[])","any[]을","anyfunct","any가","area(s:","area도","argument","array(pad","array(this.numspac","array:","array;","assertions)","assertnever(s);","assertnever(x:","assertnever는","assign","a는","b","b:","b?:","bar","basiccalcul","basiccalculator(2)","basiccalculator를","bird","bird)","bird).fly();","bird).fly)","bird):","bird는","bird를","boolean","boolean;","boolean은","boolean이","boolean입니다,","bound","box","boxed;","boxedarray","boxedarray;","boxedvalu","boxedvalue;","boxed의","broken(name:","button","button.animate(0,","c","c();","c.a","c.b","car","car;","carprops:","car는","car에","car의","case","cat","chaining를","checking)","circl","circle;","class","condit","console.log(`hello,","consolelogg","consolelogger.prototype);","const","constructor(priv","constructor(protect","constructor(publ","constructor(valu","contain","contents)","createelement(tagname:","currentvalue():","c를","declar","default:","defin","dictionari","dictionary;","dictionary['foo'];","dictionary[42];","diff","diff;","differenti","diff를","dollar","dy:","eas","easing)","easing:","element","elementtyp","else문","epithet;","error(\"unexpect","error(`expect","exclud","exclude;","exclude를","extend","extend(first:","extend(new","extend/impl","extract","extract;","f","f(1);","f(1,","f(math.random()","f(sn:","f(x);","f(x:","f1(s:","f1(x:","f2(x:","filter","filter;","first","first)","first)[prop]","first,","first[prop];","fish","fish).swim","fish).swim();","fish).swim)","fish가","fish는","fish라는","fish로","fish이면,","fixed(name:","flag","fli","fly();","fly를","foo","foo(x:","foo;","foo의","function","function>;","functionproperti","functionproperties;","functionpropertynam","functionpropertynames;","get():","getname(n:","getpaddingstring()","getpaddingstring():","getproperti","getproperty(o:","getproperty(taxi,","getproperty,","getproperty의","getrandompadder()","getsmallpet():","getsmallpet();","guard","guards)","height:","hello","hoare는","htmlimageelement;","htmlinputelement;","i'm","id:","identifier!는","identifier의","if문","implement","in\"","in\")","in\");","indentedstr","index","infer","instanceof","instanceof의","instancetyp","instancetype;","interfac","interface):","interface;","interfaced(arg:","interfaced에","interface를","in이","isfish(pet:","isfish가","isnumber(x:","isstring(x:","javascript","javascript에서","javascript에선","javascript와","javascript의","jim","jim.log(jim.name);","k","k):","k.","k[]):","k]:","key","keyof","keyof를","keyof와","keys.","keys:","keys]:","keys는","kind","kind:","k은","layeggs();","left:","lib.d.ts에","linkedlist","linkedlist;","liter","log(name)","log(name:","loggabl","loggable은","loggable입니다.","makeandmodel:","manufactur","manufacturer:","manufacturer과","map","math.pi","math.random()","math.sin(this.value);","member","mistake)\"라고","model:","modelyear","model과","model은","model이","move(pet:","multiply(operand:","multiply는","n","n();","n;","name","name!.charat(0)","name.charat(0)","name:","name?:","nameorresolv","nameorresolver):","nameresolv","nameresolver;","name의","never","never):","never;","new","newmember:","next:","nonfunctionproperti","nonfunctionproperties;","nonfunctionpropertynam","nonfunctionpropertynames;","nonnul","nonnullable)","nonnullable;","note:","null","null'에","null)","null):","null);","null;","nullabl","nullableperson","null과","null과는","null은","null을","null의","null이나","num:","number","number'","number)","number):","number)[]","number,","number;","number[]","number]:","number가","number로","number를","number일","numer를","numspaces:","n은","n을","o:","o[n]);","o[propertyname]:","o[propertyname];","o[propertyname]는","object:","operand;","operator)","option","option1:","option2:","originalprop","out\"","out\"'","out\")","out\";","ownersaddress:","pad","padder","padding:","padding에","padding이","padleft","padleft(\"hello","padleft(value:","padleft에서","padleft의","paramet","parameternam","parametername는","part","part[]","part[];","partial","partial.name은","partial;","partialperson","partialwithnewmemb","partial가","partial처럼","people.name;","people.next.name;","people.next.next.name;","people.next.next.next.name;","people:","person","person('jim'),","person.name이","person['name']","person['name']은","person[p]","person]:","person]?:","personparti","personreadonli","pet","pet)","pet.fly();","pet.fly()를","pet.layeggs();","pet.swim();","pet의","pet이","pick","pick>;","pick과","pick은","pluck(o,","pluck(o:","pluck(taxi,","pluck에","pluck처럼","polymorphism이라고","postfix(\"great\");","postfix(epithet:","predicates)","promis","prop","propa:","propb:","properties)","propertyname:","propertynames)","propertynames.map(n","propertynames:","prototyp","proxi","proxifi","proxify(o:","proxify(props);","proxify):","proxy;","proxyprop","public","purrs:","r","r;","r>","radius:","readonli","readonly,","readonly;","readonlyperson","readonly나","readonly와","record","record가","record는","record와","rectangl","result","result:","result;","result[k]","return","returntyp","returntype()","returntype;","right:","rolldice():","s","s.height","s.radiu","s.size","s.size;","s.width;","s1:","s2:","scientificcalcul","scientificcalculator(2)","scientificcalculator는","scientificcalculator을","second","second)","second):","second)[prop]","second:","second;","second[prop];","serializ","set(value:","shape","shape)","shape):","shape에","signatures)","sin","sin()","size:","sn","sn:","sn;","spacerepeatingpadd","squar","strictnullcheck","strictnullchecks가","strictnullchecks를","string","string)","string):","string,","string;","string>;","string[]","string]:","stringpadd","string라는","string이","string혹은","subparts:","super(value);","swim();","switch","switch가","s가","s는","t","t)","t):","t)>;","t,","t0","t00","t01","t02","t03","t04","t05","t1","t10","t11","t12","t13","t14","t15","t16","t17","t18","t2","t20","t21","t22","t23","t24","t3","t30","t31","t32","t33","t34","t35","t4","t40","t41","t42","t43","t5","t;","t[]","t[k]","t[k].get();","t[k][]","t[k]가","t[k]를","t[k]입니다.","t[number]로","t[p]","t[p];","t[p]에","t[p]의","t[string]은","t]:","t];","t]?:","taxi:","this.valu","this.value;","this:","this;","this를","threestringprop","throw","toni","tree","tree;","triangle;","triangle을","true","true);","type","typenam","typename;","typename은","typeof","typeof를","types)","typescript","typescript가","typescript는","typescript에는","typescript에서","typescript의","t가","t나","t는","t에","t에서","t의","t이고","t인지","u","u)","u)[]","u,","uielement","uielement();","undefin","undefined'에","undefined);","undefined;","undefined>;","undefined가","undefined는","undefined라는","undefined를","undefined와","unions)","unknown","unpack","unpacked;","unpacked>;","unpacked[]>;","unpacked[]>>;","unproxify(proxyprops);","unproxify(t:","updatepart(newname:","us","u가","u를","u에","v","value:","value;","var","variant)","void","void),","void)>;","void,","void;","void>;","vs.","width:","world\",","world\"를","x","x);","x;","x가","x는","y","y)","y)로","y:","y;","y?:","year:","year를","yike","y가","y는","y로","y를","y의","{","{}","{};","|","||","}","}.","};","}>;","}[keyof","~~~~~~~","—","가끔,","가능하다고","가능하면","가능한","가능합니다.","가드","가드,","가드는","가드라는","가드로","가드를","가드와","가드의","가장","가져와","가지","가지고","가지는","가지지","가진","가질","가집니다.","각","각각","간결합니다.","간단하게","간단하고","간단한","간주됩니다).","간주합니다.","값,","값으로","값을","값의","값이","값인지","값입니다.","갖게","갖고","갖는","같습니다:","같은","같은),","같이","개발자인","개방되어","개별","개의","객체","객체는","객체에서","객체지향","거의","검사","검사가","검사된","검사로","검사를","검사하기","검사하는","검사할","검사합니다","검사합니다.","검사합니다:","것과","것들이","것뿐입니다.","것에","것에는","것은","것을","것이","것이고","것이고,","것입니다","것입니다).","것입니다.","것입니다:","게","게다가,","결과","결과를","결정되거나","결정되거나,","결정되는","결정됩니다","결정됩니다.","결정하기","결합됩니다.","결합할","결합합니다.","겹쳐질","경우","경우,","경우는","계산기를","계층을","계층적으로","고급","고정되는","곳에서","공개된","공백이","공변","공통","공통인","과","과하다고","관계","관대한","관련되어","관련이","괜찮다고","교차","교환적으로","구문과","구문은","구문을","구문이","구별하기","구분하는","구분하여","구성","구체적으로","구현되기","구현입니다.","귀찮습니다.","균등","그","그냥","그동안,","그래서","그러나","그렇지","그리고","그만두면,","기능을","기대하는","기반으로","기본","기본적으로,","기존","까다로울","꽤","끌어내려고","끌어낼","나","나뉩니다:","나타내는","나타냅니다.","남은","내의","너무나","널러블","놀라운","누락된","느꼈습니다.","는","다","다룰","다르게","다른","다릅니다.","다시","다음","다음과","다음에","다음은","다음을","다음의","다행히,","다형성","단서","단언","단언을","단지","달라집니다.","대부분","대상","대상에","대수적","대신에","대신에,","대체할","대한","대해","더","더해질","데이터","도움이","도입하는","도입했습니다.","돌아와서","동일합니다.","동일합니다:","동작하게","동작합니다.","동적인","동형","동형이","동형이지만","되고","되어있다는","되었으니,","되지","된","된다는","될","됩니다.","됩니다:","두","두고\"십억","둘","들면","들어","들어,","들어:","들어간","등장합니다:","따라","때","때,","때가","때때로","때마다,","때문에","때문에,","때문입니다","때문입니다.","때입니다:","또","또는","또한","뜻합니다.","라이브러리를","라이브러리에","래핑","런타임","런타임에","리스트를","리터럴","리터럴로","마우스를","마지막","마찬가지로,","마찬가지입니다:","마침","막대","막지는","만드는","만들","만들기","만들수","만들어집니다","만들지","만듭니다,","만듭니다.","만약","많습니다!)","많은","말하면,","말합니다.","말했듯이,","맞지","맞추기","매개변수","매개변수가","매개변수로","매개변수를","매개변수에","매개변수와","매개변수인","매우","매핑","매핑된","매핑을","매핑이","먼저","메서드를","메시지는","멤버","멤버가","멤버는","멤버로","멤버를","멤버보다는","멤버에만","멤버의","명백해집니다.","명시적으로","명시적인","명시적일","몇","몇가지","모델링하는데","모든","목록은","목록이고","목차","못한","못할","못합니다","무슨일이","문서화의","문자열","문자열과","문자열들은","문자열에","문자열을","문자열이라면,","문제는","미리","미묘한","믹스인","믹스인이나","밀접하게","바","바인딩되는","반","반드시","반면에,","반복할","반영합니다.","반환","반환된","반환하고,","반환하는","반환하면,","반환한다고","반환할","반환합니다","반환합니다.","받고","받아들일","받지","발생","발생시킵니다","발생시킵니다.","발생합니다.","방법으로","방법은","방법을","방법의","방법이","방법입니다.","방법입니다:","방지하고","방지할","배열:","배열로","배열의","버그를","버전부터,","버전에서,","버전을","버전의","번","번째","번째,","번째는","벌어질까요?","벗겨진","변(contra","변경","변수","변수가","변수는","변수를","변수에","변수와","변형시킵니다.","변형을","변형이","변형입니다.","변환합니다.","별로","별칭","별칭과","별칭보다","별칭은","별칭을","별칭입니다:","보겠습니다:","보여주지만","보여줍니다.","보여줍니다:","보이지만,","보입니다.","보장되는","보장하는","복사하는","복사할","본문이","본질적으로","볼","봅시다:","부릅니다.","부분으로","부분을","부분집합을","분기","분기가","분기를","분기에서","분기에서는","분산","분산되었는지","분산된","분산됩니다.","불가능합니다.","불짜리","브랜치에서","비","비교될","비교를","비교하는","빠진","뽑아내는","사용되는","사용됩니다.","사용법이","사용에","사용자","사용하기","사용하는","사용하는지","사용하려","사용하면","사용하면,","사용하여","사용하지","사용한","사용할","사용합니다.","사용해보겠습니다:","사용해서","사용해야","사용했고,","살펴보겠습니다:","상호","상황을","새로운","생성자","생성하여","생성함으로써","서술어","서술어는","서술어를","서술어인","서술어입니다.","선언을","선언의","선언할","선언합니다.","선택적","선택적으로","선택적일","선택하기보단","선택하지","선택할","선택합니다:","설명한다는","설명합니다.","성공","성분으로","성분을","세","세로","섹션에서","소개합니다.","소프트웨어의","손으로","수","수는","수도","수동으로","수행한다는","수행할","순서대로","숫자","숫자/문자열","숫자나","숫자라면,","숫자만큼의","쉽게","쉽습니다:","스코프","시","시그니처","시그니처가","시그니처에서","시그니처와","시그니처의","시그니처인","시스템이","실수","실시했을","실제","실제로","실행될","싱글톤","싶어도","싶은","싶을","쓰인","아니라;","아니라는","아니면","아닌","아닙니다","아닙니다,","아닙니다.","아래","아래의","아마도","아무","아무거나","아무것에나","아주","아직","안됩니다","안에","안에서","안에서,","안에서의","안의","않는","않다면","않습니다","않습니다.","않아서","않은","않음","않지만,","알","알게","알고","알려져","알려주길","알려지고","앞에서","애매하고","애플리케이션은,","약간","약간의","얘기하지만,","어디서든지","어디에서","어디에서나","어떤","어떻게","언급한","언급했듯이,","언래핑","언래핑(unwrap)","언어에서는","얻게","얻게됩니다.","얻기.","얻을","엄격한","업데이트합니다.","업데이트해야","없고","없기","없는","없다는","없습니다","없습니다).","없습니다.","없었습니다","없으면,","없을","없이","없이,","없지만,","에디터에서","여기","여기서","여기서,","여기서는","여기에","여기에서","여러","여부로","역할을","연산","연산들은","연산자","연산자는","연산자를","연산자에","연산자입니다.","열거형","예를","예외).","예전","예제","예제가","예제는","예제들에서,","예제로,","예제를","예제에서","예제에서,","예제에서는","예제에서의","오류","오류!","오류,","오류.","오류:","오류가","오류를","오류입니다!","오류입니다.","오른쪽","오른쪽에","오른쪽은","오버로드","오버로드를","올리면","올바른","와","완전함을","완전히","왜냐하면","외","외부","왼쪽에","요소","요소가","요청한","운","원시","원한다면,","원할","원합니다.","위","위에","위에서","위에서,","위와","위의","위치를","위치에서","위해","위해,","위해서","위해서는:","유니언","유니언,","유니언.","유니언과","유니언에","유니언으로","유니언은","유니언을","유니언의","유니언이나","유니언입니다.","유사하게,","유사합니다.","유사합니다만,","유연한","유용하다는","유용하지","유용할","유용합니다.","유의하세요.","유저들은","유지하지","유효하지","유효한","을","의","의미를","의미합니다.","의존하기","이","이건","이곳에","이기","이는","이들은","이때","이런","이렇게","이를","이름","이름들의","이름을","이름이","이름이어야","이미","이상","이상의","이상적인","이슈를","이야기","이외에","이전","이제","이후부터는","익숙하다면","익숙해지는데","인덱스","인라인으로","인수","인수로","인스턴스","인스턴스화","인스턴스화에서,","인스턴스화하고,","인스턴스화하면","인식하기","인지되지","인터페이스","인터페이스는","인터페이스로","인터페이스를","인터페이스에","인터페이스와","인터페이스의","인터페이스처럼,","일","일련의","일반","일반적으로","일반적인","일부","일어나는","일이며","일치를","읽기","읽기전용","읽었고","입니다","입력","있게","있고","있기","있는","있는지","있는지에","있다고","있다는","있다면","있습니다","있습니다).","있습니다.","있습니다:","있습니다;","있어","있어야합니다.","있었습니다.","있으나,","있으면","있으면,","있으므로,","있을","있을뿐만","있음을","있지만,","잊어버렸을","잊었다면,","자기","자동으로","자신을","자주","작동하는","작성","작성되는","작성하고","작성할","작성해보겠습니다.","작성해야","작성했던","작업입니다:","작용합니다.","잘","잡는데","재","재귀적으로","적용되고","적용되지","적용하면,","적용할","적절한","전달하는지","전달하면","전달한다고","전달할","전에","전용이고","전용이었다면,","전통적인","절","절에서","점은","접근","접근하는","접근할","정보를","정의","정의된","정의만","정의하기","정의하는","정의한","정의해야","정확하게","제거","제거되어","제거된","제거하기","제거할","제거합니다.","제공합니다.","제공합니다;","제네릭","제네릭이","제안된","제약","제약조건","제약조건에서","제외.","제한할","조건","조건부","조건부가","조건부의","조건에","조건이","존재를","존재하는","존재하지","좀","좁혀집니다.","좁히고","좁히고,","좁히는","좁힙니다:","종류의","좋게도,","좋은","좋을","주목하세요,","주목하세요.","주어야","중","중에","중첩","중첩될","즉","즉,","즉시","지난","지연되는","지연될지,","지연됩니다,","지우고","지원되지","지을","지점","지정된","지정자를","지정하는","지정하면","지정할","지향","직관만","진행됩니다.","집어넣어","집합을","짓는","짧게","차별","차이가","차이점은","참조는","참조될","참조에는","참조하는","참조할","참조합니다).","처리하지","처리합니다.","철저하지","첫","초기화될","추가","추가적인","추가하고","추가하기","추가하길","추가하는","추가하면,","추가한다면,","추가합니다.","추가합니다:","추가했습니다.","추론","추론된","추론은","추론하는지","추론할","추론합니다:","추상할","추상화할","추적할","추출","추출합니다.","충돌을","충분한","충분히","커버할","컨셉들에서","컨텍스트에서","컴파일","컴파일러가","컴파일러는","케이스","케이스가","케이스들이","케이스를","코드가","코드를","코드에서","코드에서,","코드와","코드와의","코딩된","쿼리","쿼리와","쿼리처럼,","클래스","클래스가","클래스나","키고","키의","타이핑된","타임에","타입","타입\"과","타입\"을","타입,","타입.","타입과","타입들의","타입에","타입에만","타입에서","타입에서,","타입으로","타입으로,","타입은","타입을","타입의","타입이","타입이고","타입이라고","타입이라고도","타입인","타입인지","타입일","타입입니다","타입입니다,","타입입니다.","타입입니다:","태그","태그라고","템플릿입니다.","통과되고,","통합할","통해","튜플","특수한","특정","특징은","특히","틀과는","판별","판별식","판별식.","패턴","패턴은","패턴을","편하게","평가되는","평가되든지,","평가할","포함되어","포함된","포함하는","포함하지","포함할","표기하는","표준","표현","표현된","표현식으로","표현식입니다.","표현에서,","표현으로","표현은","표현하기","표현하는","표현할","프로그래밍에서","프로퍼티","프로퍼티는","프로퍼티도","프로퍼티들에","프로퍼티로","프로퍼티를","프로퍼티에","프로퍼티에만","프로퍼티의","프로퍼티인지","프록시","플래그로","피하기","필수","필요가","필요한","필터링하는데","하거나","하고","하고,","하나","하나는","하나로","하나를","하나의","하나임을","하는","하는데","하는지","하드","하려면,","하며,","하면","하면,","하위","하지만","하지만,","한","한다면,","할","할당","할당되는","할당될","할당은","할당할","할때","할지입니다.","함께","함수","함수가","함수로","함수를","함수안에서는","함수에","함수에서","함수여야","함수의","함수형","합니다.","합니다:","합니다만","합쳐","합칠","항상","해결을","해결하기","해결합니다:","해당","해줍니다.","행동을","허용되는","허용됩니다","허용됩니다!","허용하지","현재","형성하기","형식인","형태로","형태를","형태이고,","호출","호출되었는지","호출된","호출될","호출은","호출을","호출하는","호출할","호환된다면","호환됩니다.","혹은","확신할","확실하게","확인하는","확인하면","확인하세요.","확장에","효과를","후","후보가","후에","후위","훨씬","흔한"],"pages/Symbols.html":["\"c\"","\"c\";","\"value\"","'with'","(introduction)","(well","//","2015부터,","=","===","[getclassnamesymbol](){","[sym]:","array.prototype.concat를","c","c();","c[getclassnamesymbol]();","class","classnam","console.log(obj[sym]);","const","ecmascript","false,","getclassnamesymbol","instanceof","known","new","number와","obj","return","string","string.prototype.match","string.prototype.replac","string.prototype.search","string.prototype.split","sym","sym1","sym2","sym3","sym3;","symbol","symbol(\"key\");","symbol();","symbol.hasinst","symbol.isconcatspread","symbol.iter","symbol.match","symbol.replac","symbol.search","symbol.speci","symbol.split","symbol.toprimit","symbol.tostringtag","symbol.unscop","symbols)","symbol생성자를","symbol은","toprimit","{","}","};","값들은","값으로","값입니다.","같은","객체","객체가","객체를","객체의","객체입니다.","결합해","계산된","고유한","기본","나타내는","나타낼","내부","내장","내장된","다음은","대체하는","데","동작을","만드는","메서드로","메서드입니다.","메소드object.prototype.tostring로","멤버를","목록입니다:","문으로","문자열","문자열과","문자열을","문자열의","문자열처럼,","바인딩에서","반복자를","반환하는","배열","변환하는","부분","분할하는","불리언","불변하며","비교하는","사용되는","사용될","사용됩니다.","사용자","사용하여","생성자","생성자의","생성합니다.","선언과","선언할","선택적","설명을","소개","수","수도","심벌","심벌들","심벌들은","심벌들이","심벌은","심볼","알려진","어떤","언어","연관된","연산으로","연산자로","요소를","위치한","유일합니다.","이름들이","이외에도,","인덱스들에","인덱스를","인스턴스로","인식하는지","일치하는","있는지를","있습니다.","자료형입니다.","자신의","잘","정규식","정규식과","정규식을","정의","제외된","직렬로","추상","클래스","키","키로","파생된","프로퍼티","프로퍼티와","프로퍼티의","함수","해당","호출됩니다.","호출합니다.","호출해서","확인하는","환경"],"pages/Iterators and Generators.html":["\"0\",","\"1\",","\"2\"","\"4\",","\"5\",","\"6\"","\"cat\",","\"dog\",","\"hamster\"","\"hamster\"]);","\"mammals\";","\"species\"","\"string\",","(code","(iterables)","(let","(target","(var","//","0;","1,","2,","2015","3];","5,","6];","=","[1,","[4,","_i","array","array,","console.log(entry);","console.log(i);","console.log(num);","console.log(pet);","ecmascipt","ecmascript","entri","es3","es3)","es5","fals","false];","for..in","for..in은","for..of","for..of는","generation)","higher)","int32array,","list","list){","map","map,","new","num","number","numbers){","pet","pets){","pets[\"species\"]","set([\"cat\",","set,","set과","somearray","somearray)","string,","symbol.iter","symbol.iterator프로퍼티에","uint32array","var","vs.","}","가지고","간단한","간주합니다.","값","값만","값에","값에서","값은","값이","같은","같이","객체가","객체는","객체를","객체에서","객체의","검사하는","것입니다;","경우,","관심이","구현되어","구현을","구현하더라도","구현합니다.","내장","는","다르지만,","다른","다음과","다음은","대상으로","대한","들면:","등과","또","또는","루프를","루프에","루프입니다:","모두","모든","목록을","문","및","반면에","반복되는","반복자","반복자는","반복할","반복합니다.","반복합니다;","반환하고,","반환합니다.","발생합니다.","방법으로","배열의","배열이","버전","보여주는","사용됩니다.","사용하면","상위","생성","생성합니다,","생성합니다.","생성합니다:","수","숫자","아닌","엔진을","엔진의","예를","예입니다.","오류가","유형의","이러한","이런","이미","이터러블","이터러블로","이터레이터와","일부","있는","있다면","있습니다.","작동한다는","저장된","접근할","제네레이터","주로","차이점은","차이점을","컴파일러는","코드","키","타게팅","타입에는","타케팅","타케팅하는","프로퍼티","프로퍼티가","프로퍼티를","하는","함수는","허용합니다.","호출하여,","호환"],"pages/Modules.html":["!==","\"","\"*!text\"","\"*\":","\"+\":","\"./api\";","\"./calculator\";","\"./index\";","\"./lettersonlyvalidator\";","\"./mi","\"./mod\";","\"./mod\"],","\"./myclass\";","\"./myfunc\";","\"./mylargemodule.ts\";","\"./mythings\";","\"./onetwothree\";","\"./parseintbasedzipcodevalidator\";","\"./programmercalculator\";","\"./staticzipcodevalidator\";","\"./stringvalidator\";","\"./utilities\";","\"./validation\";","\"./xyz.txt!text\";","\"./zipcodevalidator\";","\"/\":","\"0\"","\"001+010=\");","\"1\",","\"1+2*33/11=\");","\"101\"];","\"123\"","\"123\";","\"2\",","\"3\",","\"4\",","\"5\",","\"6\",","\"7\",","\"8\",","\"9\",","\"98052\",","\":","\"=\")","\"a\",","\"ambient\"라고","\"b\",","\"c\",","\"d\",","\"doe","\"e\",","\"exports\",","\"f\"];","\"function\"","\"hot","\"jquery\";","\"json!*\"","\"json!*\"와","\"json!http://example.com/data.json\";","\"matches\"","\"math","\"module\"","\"next","\"object\"","\"object\")","\"path\"","\"thing\";","\"url\"","\"url\";","\"url\"을","\"발견\"할","\"최상위","$","$(\"button.continue\").html(","$:","$;","${","${maxbase}","${validate(s)","$나","$와","&&","'${char}'`);","'numberregexp'","'parseintbasedzipcodevalidator'","'regexpbasedzipcodevalidator'","'stringvalidator'","'zipcodevalidator'","'zipcodevalidator.ts'","'상위'","(...args:","(ambient","(amd),","(base","(char","(code","(commonjs),","(digit","(do","(dynam","(es6)","(explicitli","(export","(factory)","(foo를","(function","(guidanc","(if","(import","(introduction)","(let","(mod_1_1)","(needzipvalidation)","(option","(programmercalculator.digits.indexof(digit)","(re","(red","(require,","(require을","(s:","(sample:","(shorthand","(simpl","(this.operator)","(typeof","(umd","(use","(v","(validator.isacceptable(\"...\"))","(valu","(wildcard","(work","(x.isacceptable(\"...\"))","(zipcodevalidator:","(간단한","(변수,","(스크립트는","(전역","(하나의",");","*","*/","+","...",".d.t",".h",".js파일이","/","/*","//","///","/^[0","/^[a","/collections/generic/","0","0)","0;","1);","10이","1;","2015","2015부터","2015와","3","3.8","3.8에서는","5","9","9]+$/;",":","=","===","=>","=를","=와",">=","?","[\"0\",","[\"hello\",","[s:","access","advanc","allvalidators.t","ambient","amd","amd를","amd와","any;","any[])","any[]):","api","api를","app.t","base:","boolean;","c","c#의","c/c++에","calcul","calculator();","calculator(2);","calculator,","calculator.t","calculator로","calculator를","case","cat","class","class나","close","code\"]","commonj","commonjs를","commonjs와","console.log(`\"${","console.log(`\"${s}\"","console.log(data,","console.log(f());","console.log(num);","const","constructor()","constructor(publ","consumer.t","content:","content;","current","currentvalu","currentvalue:","data","declar","declaration)","declaration)을","declarations)","declarations.d.t","default","default)","default를","defin","define([\"require\",","define,","define.amd)","digit","dog","dynam","ecmascript","effect","entir","error(`bas","error(`unsupport","evaluate()","evaluateoperator(operator:","example)","execute:","export","export\"가","exports)","exports);","exports,","exports.t","exports_1(\"t\",","exports가","exports는","exports도","exports로","exports를","exports에","export가","export는","export되는","export된","export로","export를","export만","export한","export할","extend","extend)","f","factory(require,","factory);","filecont","filecontent);","flags)","flower","foo","foo로","function","function()","function(exports_1)","function,","function을","gener","getresult()","getthing()","handlechar(char:","hostname?:","id","implement","import","imports나","imports는","import나","import는","import로","import를","import문을","import할","inclusive.`);","input:","interfac","isacceptable(s:","isolatedmodul","isprim","isprime(2);","isprime(x:","javascirpt","javascript","javascript로","javascript에는","javascript에서","join(...paths:","jqueri","jquery.d.t","jquery;","jquery와","js","larg","left","left:","lettersonlyvalid","lettersonlyvalidator();","lettersonlyvalidator.t","lettersregexp","lettersregexp.test(s);","level","level)","lib\";","lib.d.t","libraries)","list","load","log.t","m","m.someth","mainvalid","match\"","match\"}`);","math","mathlib.isprime(2);","mathlib;","maxbas","maxbase)","memori","mod_1","mod_1)","mod_1.someth","mod_1;","mod_1_1;","modul","module\";","module)","module.export","module.js\"","modules)","modules를","multipl","my.application.customer.addform과","my.application.order.addform","myclass.t","myfunc.t","mylargemodul","mylargemodule.dog();","mylargemodule.t","mythings.t","myurl","myvalid","name","names)","namespac","nativ","new","node","node.d.t","node.d.ts를","node.j","node.js)","node.js에서","node.js에서는","node.js의","normalize(p:","ns를","num","number","number)","number):","number,","numberregexp","numberregexp.test(s);","objects,","onetwothree.t","onload:","only\"]","only)","operator:","operator;","parse(urlstr:","parseint(s).tostring()","parseintbasedzipcodevalid","parseintbasedzipcodevalidator.t","parsequerystring?,","pathname?:","pattern","possible)","privat","processdigit(digit:","programmercalcul","programmercalculator.digits.indexof(digit);","programmercalculator.digits.length;","programmercalculator.t","programmercalculator.ts을","protect","protocol?:","public","put","re","regexpbasedzipcodevalidator}","regist","requir","require(\"...\")","require(\"./mod\");","require(\"./zipcodevalidator\");","require(\"mod\");","require(\"module\")를","require(\"url\");","require()","require())","require([\"./zipcodevalidator\"],","require(modulename:","require(modulenames:","require.j","require.js)","require.js에서","require.js의","requirej","return","return;","right:","right;","s","s.length","s;","scenarios)","sep:","setters:[","side","simplemodule.j","simplemodule.t","singl","slashesdenotehost?):","somefunc","somefunc()","somefunc();","someth","sometyp","sometype();","sometype,","statements)","static","staticzipcodevalidator.t","step...\"","string","string)","string):","string,","string;","string[],","string]:","strings.foreach(","stringvalid","stringvalidator.t","stringvalidator;","structur","super();","switch","system","system.collections에서","system.import(\"./zipcodevalidator\").then((zipcodevalidator:","system.js)","system.js에서","system.register([\"./mod\"],","system:","systemjs,","systemjs나","t","t();","t)을","t;","test","test(c,","test(c:","test.t","testcalculator.t","testprogrammercalculator.t","things)","this.bas","this.curr","this.current);","this.current;","this.evaluate();","this.evaluateoperator(this.operator,","this.memori","this.memory,","this.memory;","this.oper","this.processdigit(char,","this.processoperator(char);","throw","top","tree","tsc","type","typeof","types)","typescript","typescript는","typescript로","typescript에","typescript에서는","type은","type을","umd","umd,","undefined)","url","url.parse(\"http://www.typescriptlang.org\");","url;","us","util","v","v;","valid","validation.t","validator();","validator.isacceptable(s)","validator.zipcodevalidator();","validators)","validators:","validators[\"lett","validators[\"zip","validators[name].isacceptable(s)","validator를","validator의","valu","value:","value;","var","variable,","void):","void;","within","x","x(y);","x)","x,","x로","y","you'r","z]+$/;","za","zcv","zcv();","zip","zip();","zip)","zipcodevalid","zipcodevalidator();","zipcodevalidator.numberregexp.test(s);","zipcodevalidator.t","zipcodevalidator.zipcodevalidator();","zipcodevalidator:","zipcodevalidator;","{","{apiresponsetype}","{y}","{zipcodevalid","{};","{를","}","}\"","})(function","});","};","}],","}`);","}인","가까운","가깝게","가능하다는","가능한","가능합니다.","가능합니다:","가정을","가져와","가져와야","가지","가지고","가진","가질","가질만한","가집니다.","각","간단하게","간단한","간의","간접","간주합니다.","감쌀","감지합니다.","값도","값을","값의","같은","같이","같지만","개념을","개념이","개의","개체를","개체와","객체가","객체로","객체를","객체와","객체의","거라","거의","것도","것들을","것은","것을","것이","것이라면,","것입니다.","것처럼,","결과를","결합될","결합할","경로와","경우","경우,","경우를","경우에는","경향이","경험을","계산기","계산기의","계층에서","계층적","고급","고려하세요.","고통스러운","공유합니다.","과도하게","과도한","관계는","관련된","관심이","관점에서","구문은","구문을","구성","구성을","구성하여","구성할지","구조를","구조화에","구현을","구현하여","권장되지는","그","그러나","그룹화하는데","그리고","금방","기능도","기능에","기능은","기능을","기반","기존","기존의","기타","나","나열","나은","나중에","내보내기","내보냄","내부에서","내에서","내에서만","내용은","내용을","너무","네이밍","네임스페이스","네임스페이스,","네임스페이스는","네임스페이스로","네임스페이스를","네임스페이스에","네임스페이스와","노출된","노출하는","노출합니다.","논리적","논리적으로","높이지","다","다루기","다룰","다른","다시","다음","다음,","다음과","다음은","다음처럼","단일","단축어처럼","대부분의","대상에","대상을","대체","대체하는","대한","대해","더","도구는","도입하는","도입하지","동일한","동작에서","동작하려면","동적","동적으로","되면,","되지","될","됩니다.","두","두고","두세요","둘","둘은","들면:","들어","들어,","등은","등을","따라","때","때,","때:","때는","때때로","때만","또는","또한","라는","라이브러리는","라이브러리를","라이브러리와","라이브러리의","래핑","런타임","레벨","레벨로","레벨에","레벨의","레이어가","레이어를","로더가","로더는","로더로는","로더를","로더에서","로더와","로더의","로드하도록","로드하여","로드할","로딩","로딩과","리스트","릴리즈","마세요","마세요!)","마찬가지).","마찬가지로","마찬가지로,","마찬가지입니다.","마찰을","마찰이","만들","만들려고","만들면,","만들어보겠습니다.","만큼","많은","메서드에도","명령","명시적으로","명확하게","몇","모델링","모두","모듈","모듈과","모듈당","모듈도","모듈들을","모듈로","모듈로부터","모듈에","모듈에는","모듈에서","모듈은","모듈을","모듈의","모듈이","모듈이라고","모든","목록을","목적이","문","문서를","문은","문을","문자열","문자열이","문제가","및","바꿔야","바벨","반대로","반드시","반면,","발생하지","발췌)","방법으로","방법은","방법을","방식과","방식으로","방출되는","변경","변경하지","변수)","변수,","변수로","변수로도","변수를","변형하지","변환되는","별도의","별칭,","별칭으로","병합(merge)","보강하는","보강하지는","보여줌","보여줍니다","보여줍니다.","보이는","보이지","볼","부릅니다.","부분적으로","부수효과만을","불가능합니다.","불필요합니다.","블록에","비","비슷한","빠르게","사용","사용되거나,","사용되는","사용되도록","사용된","사용된다면","사용될","사용자","사용자가","사용자는","사용자를","사용자에게","사용자의","사용하기","사용하기가","사용하는","사용하세요","사용하세요.","사용하세요:","사용하세요;","사용하여","사용하지","사용하지만,","사용한","사용할","사용합니다.","사용해","살펴보겠습니다.","상속된","상속을","상속하여","상태로","상황에","새로","새로운","샘플","샘플:","생각하지","생각할","생각해보세요.","생각해야","생성","생성된","생성합니다.","선언","선언(shorthand","선언된","선언들은","선언만","선언으로","선언은","선언을","선언이","선언해야","선언형입니다;","선택사항","선택적","선택적으로","선택적으로,","선택하므로","설계되었습니다.","설명하려면,","설정합니다.","성능을","소개","속기","수","수정해서","수준을","수준의","수행한","수행합니다.","숫자를","쉬워집니다.","쉽습니다.","스코프","스코프가","스코프로","스코프에서","스크립트","스크립트로","시","시나리오","시나리오를","시나리오와","시스템에","시작할","시험용","식별자가","신중하게","신호","신호입니다.","실제로","실행됩니다;","실행하기","실행해야","심벌은","아닌","아래","아래에","아래에서는","아래의","아이디어는","안","안에서","안전성을","않고","않는","않습니다.","않아도","않았는지","않은","않지만,","앞에서","애플리케이션의","양식","양식을","어떤","어떻게","언급했듯이","없거나,","없는","없습니다.","없이","에","여기서","여러","여부를","역할을","열거형이","염두에","예를","예입니다.","예제","예제는","예제를","예제에서","오류:","오직","와","와일드카드","외부","외부에서","용","용도가","우리는","우연한","워크플로우를","원래","원하는","웹","위의","위치(즉,","위치에","위치에서","위치에서는","위한","위해","위해,","위해서,","위해서는","위험","유명한","유사하게","유사한","유용한","유지하기","의도를","의미를","의존성을","의존적인","이","이것은","이것을","이동하세요)","이러한","이렇게","이를","이름","이름(이","이름과","이름으로","이름은","이름을","이름이","이미","이상의","이유는","이전","이전에는","이제","익숙하다면,","인용된","인터페이스","인터페이스)를","인터페이스,","인터페이스를","일반적으로","일반적인","일부","일부는","일치하는","읽을","잃지","입니다.","입력","입력받을","있고","있고,","있는","있도록","있습니다","있습니다.","있습니다:","있었습니다.","있으며,","있으므로,","있지만,","자세한","자체","자체에","작동하는","작성되지","작성될","작성하는","작성하여","작성하지","작성할","작업은","재사용하기","저장하는","적어야","적용되는","적용할","적합한","전달하고","전면에서","전에","전역","전체","점을","접근에","접근이","접근할","접두사","접미사를","정말","정보는","정보를","정보에서","정의","정의되어","정의된","정의를","정의하지","정의할","정적","제거","제거되며,","제거하고","제거하면","제공하는","제공합니다.","조건에서만","존재합니다.","종종","좋은","주요","줄에서","줄여주는","중","중에","중에는","중요합니다.","중첩","즉","지역","지역적으로","지원합니다.","지점이","지정된","지정됩니다.","지정할","지정합니다.","지정해야","지침","직접","찍지","참고하세요","참조","참조를","참조하는데","찾고","찾기","찾을","처리됩니다(모듈에서도","처음","체계를","최상위","최적입니다.","최적화를","최적화할","추가됩니다.","추가적인","추가하는","추가하면","추가하여","추가합니다.","추천하는","출력","충돌은","충돌을","측면에서","컬렉션","컴파일","컴파일러","컴파일러는","컴파일이","코드","코드로","코드를","코드에","코드의","큰","클래스","클래스,","클래스를","클래스에","클래스의","키워드는","키워드로","키워드를","타입","타입,","타입에","타입을","타입의","태그와","테스트입니다.","테스트입니다:","테스트할","통과하는지","통과했는지","통합합니다.","통해","통해)","특수한","특정","특정한","파일","파일들을","파일로","파일에","파일은","파일을","파일이라고","파일입니다.)","패턴은","패턴을","패턴의","패턴이","편리합니다.","포함된","포함하는","폴더를","표시됩니다;","표시로만","표시합니다.","표현식이","표현이나","플래그를","피하기","필드로","필요가","필요할","하거나,","하기","하기는","하기와","하나","하나라도","하나를","하나의","하는","하려면,","하면","하지","하지만","하지만,","한","할","함)에서만","함께","함수","함수,","함수도","함수를","합니다.","합니다:","합니다;","항상","해당","해서,","해석하기","해야","핵심","헬퍼","형태를","호출","호출됩니다.","호출은","호출할","호환되지는","혹은","확인하세요.","확인하세요:","확장(extensions)으로","확장이","확장하고","확장해야","활용하므로","후","힘들어지는"],"pages/Namespaces.html":["\"101\"];","\"98052\",","\"ambient\"라고","\"doe","\"matches\"","${","&&","'${","'new","(\"name\")","(aliases)","(ambient","(element:","(first","(introduction)","(let","(multi","(namespac","(namespacing)","(selector:","(split","(tabl","(valid","(work","(간단한","(기본값)을","(예:","(인용)",".d.t",".h","//","///","/^[0","/^[a","5","9]+$/;",":","=","===","?","[\"hello\",","[s:","ambient","api를","base","boolean;","c/c++에","class","code\"]","console.log(`\"${","console.log(`'${","const","contents)","d3","d3.base;","d3.d.t","d3:","d3이라는","declar","each","event","event:","event;","eventtarget):","export","export를","extend","file","file)","files)","implement","import","import는","interfac","isacceptable(s:","ismatch","javascript","js","letterregexp와","lettersonlyvalid","lettersonlyvalidator();","lettersonlyvalidator.t","lettersonlyvalidators.t","lettersregexp","lettersregexp.test(s);","libraries)","match\"","mytestpage.html","name","namespac","namespaces)","new","number;","numberregexp","numberregexp.test(s);","numberregexp는","only\"]","outfil","output)을","pass","polygon","polygons.square();","q","requir","return","s","s.length","sampl","sample.j","select:","selection;","selector","shape","shapes.polygons.square()'와","shapes.polygons;","show","singl","sq","squar","steps)","string","string)","string):","string]:","strings)","stringvalid","stringvalidator;","stringvalidator{","test.t","tri","triangl","tsc","typescript","typescript로","typescript에서","us","valid","validation.letteronlyvalidator).","validation.lettersonlyvalidator();","validation.stringvalidator;","validation.t","validation.zipcodevalidator();","validation{","validation이라는","validators)","validators:","validators[\"lett","validators[\"zip","validators[name].isacceptable(s)","validators[name].isacceptable(s);","var","var를","var에","whether","x","x.y.z를","x:","y:","z]+$/;","za","zipcodevalid","zipcodevalidator();","zipcodevalidator.t","zipcodevalidators.t","{","{};","}","}\"","}'","}'.`);","};","}`);","↥","가능하도록","가져오기(일반적으로","가져오기에서","가져오는","가져온","가지","각","간","간단한","간략하게","간의","감싸겠습니다.","값의","같은","같이","개","개별","개별적으로","개체를","객체들을","객체를","객체만","객체에서","객체와","객체의","검사기","검사기를","검증해야","것과","것을","것이","것입니다.","것처럼","게시물에서는","경우","경우,","곳에서","관계를","관련","구문과","구문은","구성하는","구조","구현","구현을","규모가","그","기능을","기반으로","기여할","내보내지","내용은","널리","넣는","네임","네임스페이스","네임스페이스로","네임스페이스를","네임스페이스에","네임스페이스화된","노출하므로","다른","다양한","다음과","다중","단계","단순화할","단순히","단일","대부분의","대신","대신)","대신,","대한","대해","대해서도","더","데","데이터","동일","동작합니다.","되면,","두","들어","들어:","때","또","또는","라이브러리가","라이브러리는","라이브러리로","라이브러리의","로더","로드되는지","로드되므로(모듈","로드하기","로드하는","마치","만들기","많은","많이","먼저,","명심하세요;","몇","모두","모듈","모듈을","모든","목차","문자열","문자열이","및","반영되지","받은","방법은","방법을","방법이","방지하기","번째","변경","변경되지","변수","변수에","별개의","별칭","별칭을","별칭이라고","보기","보수가","볼","부릅니다.","분리되어","분할","분할합니다.","분할해야","붙입니다.반면,","비슷하지만,","사용되는","사용될","사용자","사용하는","사용하여","사용하지","사용할","사용합니다.","사용해야","사항이므로","살펴보겠습니다.","샘플","생각할","생성되는","생성된","생성할","생성합니다.","선언부에","선언을","선언할","선언해야","설명하려면,","설명합니다.","세부","세트를","소개","소수의","수","수도","수행하는","순서로","스페이스","시도해","시작하겠습니다.","식별자에","심벌에","심벌와","심벌은","심벌의","않기","않는다는","않습니다.","않아","않았습니다.","않은","알립니다.","애플리케이션","양식에","없습니다.","여기서","여러","연결","예를","예에서는","예제로","옮기겠습니다.여기서","외부","외부로","외부로부터","외부에","외부에서","외부에서도","외에","용이합니다.","원래","웹","위로","위해","위해,","유지","의미에","의존성이","이","이것은","이러한","이를","이름","이름으로","이름을","익숙하다면","인용)","인터페이스","일반적으로","일종의","입력","입력을","있고","있는","있습니다.","있습니다:","있어도","있으면","자동으로","작성되지","작성할","작성했습니다.","작업을","작업하기","적용하기","적절한","전역","전체에서","접근","접근할","정렬합니다.","정의되어","정의된","정의하기","정의하지","정의합니다.","정해진","제공하는","존재하므로,","종류의","좋습니다.","지정할","직접","짧게","참조","참조이므로","첫","체계가","최상위","추가하게","추가하여","추적하고","출력","출력(concaten","충돌을","커지면,","컴파일","컴파일된","컴파일러는","컴파일러에게","컴파일하기","코드가","코드는","코드를","코드에서","코드에서,","클래스가","키워드를","타입","타입을","타입의","태그를","테스트","통과했는지","통해","특정","특히,","파일","파일로","파일별","파일에","파일을","파일의","파일이","페이지","페이지에서","페이지의","포함하여","표시","프로그램을","플래그를","필요합니다.","하나의","하단의","한","할당합니다.","함)는","합니다","합니다.","형식을","형태를","혼동하지","확인하거나","확인하기","확인해야"],"pages/Namespaces and Modules.html":["\"...\";,","\"./shapes\";","\"somemodule\"","\"somemodule\";","'내부","(introduction)","(needless","(pitfal","(trade","(use","(예를","*","*/","...","...)",".d.t",".d.ts를",".t",".ts,",".tsx를","/*","//","///","1.8","2015부터,","=","amd","class","commonj","commonjs/require.js)에","declar","ecmascript","es","export","fn():","function","html","import","import문","javascript","js","m","modul","module)","modules)","mymodules.d.t","myothermodule.t","namespac","namespaces)","namespacing)","new","node.d.ts파일을","node.j","off","outfil","outfile을","refer","require(\"...\");","shape","shapeconsumer.t","shapes.shapes.triangle();","shapes.shapes?","shapes.t","shapes.triangle();","shapes는","squar","square을","string;","system를","t","triangl","triangle과","typescript","typescript는","typescript만의","typescript에서","umd를","x","{","}","가져오는","가지","가지고","간단히","간략하게","감싸고","감싸줄","강력한","같은","개의","객체로","객체를","것입니다.","것처럼,","결정하기","경로에","경우","경우,","경우에는","경우와","계층을","고급","고립성과","고유한","관한","구문을","구성하는","구조로","구조의","구조화하기에","구조화하는","구현은","권장하는","권장합니다.","그","그룹을","글에서는","기본적으로","기본적인","기억하세요.","나은","내보내는","내부에서","내용은","내용의","내재한","네임스페이스","네임스페이스가","네임스페이스는","네임스페이스를","네임스페이스에","네임스페이스에서","네임스페이스와","논리적","다","다른","다시","다양한","다음","다음과","다음은","단순한","달리,","대규모","대상으로","대신","대응인","대응입니다.","대한","더","덕분에","데","도구를","동안에는","되기","되는","되었습니다.","두","둘","둘의","들어,","등","따라서","따라서,","때","때문에","때문에,","또는","또한","런타임을","로더(예:","를","마주치는","마찬가지로","만들","만약","말하면,","매우","몇","모듈","모듈'이라고","모듈(ambient","모듈과","모듈로","모듈에","모듈에는","모듈은","모듈을","모듈의","모듈이","모든","모습이","목적은","못한다면,","문서를","미리","발생하는","방법으로","방법은","방법을","방법이며,","방법입니다.","방지하기","버전의","번들링을","변경하면,","부분이며,","불가능할","불렸습니다.","불필요한","붙여집니다.","사용자가","사용자에게","사용하기","사용하느냐에","사용하는","사용하던","사용하여","사용한","사용할","사용해","살펴볼","새로운","샘플에서","생성된","서로","선언","선언을","선언이","선언해야","설명합니다.","설정하지","소개","소스","수","수정된","쉽습니다:","스스로","스코프","시스템을","시스템인","식별하기","실수는","심벌을","아닌","아무런","아주","안에","안의","않는다는","않아도","알아보겠습니다.","애플리케이션에서","애플리케이션의","앰비언트","어떤","어떻게","언어에서","없습니다.","없이","없지만,","엔진","여기서는","여러","연결할","예를","예입니다:","오래된","오염되는","오프","옵션을","우선","웹","위의","위치를","위치한","위한","위함입니다.","위해","위해,","위험성","위험성과","위험성을","유발합니다:","유의해야","의미","의존성은","의존성을","의존성이나","의해","이","이것들을","이러한","이런","이를","이름","이름은","이름을","이미","이유를","이전의","이해하기","이해해야","이후부터,","일대일","일반적인","있게","있기","있습니다.","있어","있으며,","자세한","자주","작업이","재사용성을","적절한","전역","절대","점","점은","점을","점입니다.","접근법이라는","정보를","정의되고,","제공하고","제공하지","제공합니다.","좋은","주제와","중","중요한","지원하는","지원해야","지정하는","짜증을","차이를","참고:","참고하세요.","참조하기","찾습니다.","찾아내는지를","찾은","찾지","최상위","추가적인","충돌을","컴파일러가","컴파일러는","컴포넌트의","코드","코드를","코드에","코드와","타입","탐색할","태그는","태그로","트레이드","특성","특정","특징","특히","파일","파일:","파일과","파일도","파일안에","파일에서","파일은","파일을","파일의","파일이","페이지의","포괄할","포함된","포함될","포함합니다.","프로그램을","프로젝트의","필요가","필요합니다.","하나는","하는","한다는","할당할지를","합니다.","합치는","해결책을","향상된","형성하고","호환","혼동과","흔히","힘들게"],"pages/Module Resolution.html":["\"*\"","\"*\",","\"*\":","\".\",","\".\"가","\"../constants/http\";","\"../node_modules/jquery/dist/jquery\"로","\"./components/entry\";","\"./moduleb\"","\"./moduleb\"`는","\"./moduleb\"의","\"./src\"로","\"./template\"처럼","\"/mod\";","\"@angular/core\";","\"baseurl\":","\"baseurl\"에","\"baseurl\"을","\"compileroptions\":","\"exclude\"","\"exclude\"를","\"files\"","\"files\"를","\"generated\"가","\"generated/*\"","\"generated/templates/views\"","\"jquery\"","\"jquery\":","\"jquery\";","\"lib/mainmodule.js\"","\"main\"","\"main\":","\"main\"의","\"modulea\"","\"modulea\"같은","\"modulea의","\"moduleb\"","\"moduleb\"는","\"moduleb\"의","\"moduleb\"처럼","\"node_modules/jquery/dist/jquery.slim.min.js\"로","\"paths\"","\"paths\":","\"paths\"가","\"paths\"를","\"rootdirs\":","\"rootdirs\"는","\"rootdirs\"를","\"src/#{locale}\"","\"src/de\",","\"src/views\",","\"src/zh\",","\"types\"라는","\"typescript\"","\"很高兴认识你\"","\"您好吗\",","\"가상\"","\"가상\"디렉터리","\"배포\"되는","\"추가\"","\"프로젝트\"로","#{locale}와","$","'","'*'","'*'은","'./#{locale}/messages'를","'./lib/typescript.d.ts'","'./lib/typescript.d.ts'가","'./template1')","'./view2')","'./zh/messages'로","'folder1/file2'","'folder1/file2':","'folder2/file3')","'folder2/file3':","'generated/*'","'modulea'가","'modulea와","'moduleb.","'node_modules'","'node_modules/typescript.d.ts'","'node_modules/typescript.ts'","'node_modules/typescript.tsx'","'node_modules/typescript/lib/typescript.d.ts'","'node_modules/typescript/lib/typescript.d.ts'.","'node_modules/typescript/lib/typescript.d.ts'로","'node_modules/typescript/lib/typescript.d.ts'를","'node_modules/typescript/package.json'.","'nodej","'nodejs'.","'package.json'","'package.json'은","'rootdirs'를","'src/app.ts'","'src/app.ts'.","'src/node_modules/typescript.d.ts'","'src/node_modules/typescript.ts'","'src/node_modules/typescript.tsx'","'src/node_modules/typescript/package.json'","'tsconfig.json'안에","'tsconfig.json'의","'types'","'typesciprt'","'typescript'","'typescript'는","(\"main\"","(\"modulea의","(\"types\"","(.ts,","(17)에서","(4)","(7)에서","(9)와","(addit","(base","(classic)","(common","(how","(i.e.","(import","(modul","(node)","(path","(rel","(thing","(trace","(use","(virtual","(whi","(만약","*","../.","./","./#{locale}/messages를","./#{locale}/messages와","./de/messag","./zh/messages,","./zh/messages는",".d.ts)를",".d.ts에",".js로",".ts/.tsx",".tsx",".ts파일을","/,","//","///","/generated/templates/views를","/generated/로","/moduleb.d.t","/moduleb.t","/node_modules/@types/moduleb.d.t","/node_modules/moduleb.d.t","/node_modules/moduleb.j","/node_modules/moduleb.t","/node_modules/moduleb.tsx","/node_modules/moduleb/index.d.t","/node_modules/moduleb/index.j","/node_modules/moduleb/index.t","/node_modules/moduleb/index.tsx","/node_modules/moduleb/package.json","/root/moduleb.d.t","/root/moduleb.t","/root/node_modules/@types/moduleb.d.t","/root/node_modules/moduleb.d.t","/root/node_modules/moduleb.j","/root/node_modules/moduleb.t","/root/node_modules/moduleb.tsx","/root/node_modules/moduleb/index.d.t","/root/node_modules/moduleb/index.j","/root/node_modules/moduleb/index.t","/root/node_modules/moduleb/index.tsx","/root/node_modules/moduleb/package.json","/root/src/folder/a.ts안에","/root/src/folder/moduleb.d.t","/root/src/folder/moduleb.t","/root/src/modulea.js가","/root/src/modulea.js에","/root/src/modulea.t","/root/src/modulea.ts안에","/root/src/moduleb","/root/src/moduleb.d.t","/root/src/moduleb.js라는","/root/src/moduleb.t","/root/src/moduleb.tsx","/root/src/moduleb/index.d.t","/root/src/moduleb/index.t","/root/src/moduleb/index.tsx","/root/src/moduleb/lib/mainmodule.js를","/root/src/moduleb/package.json","/root/src/moduleb/package.json파일을","/root/src/node_modules/@types/moduleb.d.t","/root/src/node_modules/moduleb.d.t","/root/src/node_modules/moduleb.j","/root/src/node_modules/moduleb.t","/root/src/node_modules/moduleb.tsx","/root/src/node_modules/moduleb/index.d.t","/root/src/node_modules/moduleb/index.j","/root/src/node_modules/moduleb/index.t","/root/src/node_modules/moduleb/index.tsx","/root/src/node_modules/moduleb/package.json","/src/view와","/으로","=","========","=>",">","[","[\"node_modules/jquery/dist/jquery\"]","[노드][#노드","[클래식][#클래식","]","];","ad","addit","ambient","amd","app.t","app.ts는","app.ts의","a의","b","baseurl","baseurl과","baseurl로","baseurl에","baseurl을","baseurl의","classic]이고","compil","compiler?)","compon","default","defaulthead","directori","entri","error","es2015에서는","exclud","exist","exist.","expect","export","field","file","file1.t","file2.t","file3.t","final","find","flag","flags)","folder.","folder1","folder1/file2","folder2","folder2/file3","for)","found","gener","generated/folder2/file3","generated/templ","happen","hoc,","imoprt가","import","imports)","import가","import나","import는","import를","import에서","import에서는,","import은","import의","import하는","index.j","index.js를","inform","jquery는","jquery를","kind","list","load","look","mapping)","modul","modulea","modulea.t","modulea는","modulea를","moduleb.j","moduleb를","moduleb의","moduleresolut","modules)","name","node.j","node.js가","node.js는","node.js의","node].","node_modul","node_modules로","node_modules에서","node_modules을","node는","node의","non","noresolv","noresolve)","noresolve를","npm","out","output.","package.json라는","package.json안에","package.json을","pick","projectroot","projectroot/folder1/file2.t","projectroot/folder2/file3.t","projectroot/generated/folder2/file3.t","questions)","refer","rel","requir","require(\"./moduleb\");라는","require(\"moduleb\");","requirej","requirejs와","require에","resolut","resolution)","resolv","result.","root","rootdir","rootdirs)","rootdirs를","rootdirs의","roots를","set","sourc","specified,","src","src/view","still","strategies)","successfulli","system","systemj","templat","template1.t","traceresolut","traceresolution'을","traceresolution으로","transform","ts","ts2307:","tsc","tsconfig.json","tsconfig.json는","tsconfig.json를","tsconfig.json은","tsconfig.json의","type","typescript","typescript.d.t","typescript가","typescript는","typescript의","ui","up","url","url)","us","var","view","view1.t","view2.t","vs.","x","{","|","}","}을","│","└──","└───lib","└───src","└───typescript","├──","├───node_modul","가끔","가능하고,","가능한","가능합니다.","가상","가상의","가정합니다.","가져온","가지","가지고","가질","각","간단합니다.","간단해","간주됩니다.","값","값)","값,","값은","갖고","같습니다.","같습니다:","같아야","같은","같이","개발할","개의","거슬러","검사하기","검사해야","것보다","것에","것으로","것은","것을","것이","것이기","것이다.","것입니다.","것입니다:","것처럼","결과","결과가","결과는","결정됩니다:","결합","결합되어","경로","경로가","경로는","경로를","경로와","경로의","경우","경우,","경우가","경우에,","계산됨)","고려해봅시다.","곳에","공통","과","과정","과정을","관계를","관계없는","관계없이","구성을","구성하는","구조를","국제화","그","그래서","그러고","그러나,","그렇게","그렇습니다),","그리고","그에","기능을","기대할","기본","기준으로","기초적인","나","나머지는","나서","나서,","나옵니다:","나중에","나타내는","나타냅니다.","내에서","내용물이","내용은","내장","노드","노드와","노드입니다.","논리적으로","논의한","높을","는","다는","다루게","다룰","다르게","다른","다음","다음과","다음에","다음을","다음의","단계에서","단일","달라집니다.","달성하기","대상으로","대신","대체","대체로","대체의","대한","대해","대해서는","더","동일한","동작은","되었습니다.","될","됩니다.","두","두려워하지","들어","들어,","들어:","등으로","디렉터리","디렉터리,으로","디렉터리가","디렉터리로","디렉터리를","디렉터리부터","디렉터리에","디렉터리의","디폴트","디폴트는","따라","따라서","따라서,","따르는","따르면,","따를지","따릅니다,","따릅니다:","때","때,","때까지","때도","때때로","때마다,","때문에","때문에,","라는","런타임","런타임에","런타임에서,","런타임의","레벨이거나,","레이아웃은","레이아웃이","로그가","로더","로더는","로더를","로드하기에서","로드하려는","로딩","로직","로직을","로케일","로케일에","로케일을","마세요","마지막으로,","마치","만들","만듭니다.","만약","많은","맞는","매핑","매핑도","매핑됩니다.","매핑에","매핑으로","매핑은","매핑의","매핑이","매핑하기","메커니즘을","명령","명령줄로","모두","모듈","모듈과","모듈들의","모듈들이","모듈만","모듈에","모듈에서","모듈은","모듈을","모듈의","모듈이","모듈임을","모든","모방하려고","모방합니다.","모을","목록에","목록에서","목록을","목적","무엇을","무엇인가?","문서","문서는","문서를","문서에","문서에서","문서와","문은","문을","문자열","물리적","뭘까?\"라고","밑에서","바꿉니다.","바뀌지","바뀝니다.","바와","바인딩","반드시","반영하기","받지","발생:","발생한","발생할","발생합니다.","방문할","방법","방법에","방법으로","방법이","방법입니다.","배열은","배열을","버전과의","번","번들링과","번들을","번역됩니다.","번째","번째로","번째로,","변환도","변환을","병합","병합되는","병합할","보간하여","보도록","보세요.","보십시오:","보이지만,","보일","보입니다.","보입니다:","보장하는","복사하는","복사합니다.","복잡하지","복잡한","볼","봐야","불리는","뷰는","비","비슷하게,","빌드","빌드의","사용","사용.","사용됩니다.","사용을","사용하고","사용하고,","사용하기","사용하는","사용하면,","사용하세요.","사용하십시오.","사용하여","사용한","사용합니다","사용합니다,","사용합니다.","사용해야","상기해봅시다.","상대","상대적","상대적으로","상대적이냐에","상대적이라고","상대적이라면","상대적이면,","상대적인","상대적임.","생각해보세요.","생각해보세요:","생각해보세요;","생각해봅시다.","생성기에","생성된","생성하기위해","생성하는","생성합니다.","선언으로","선언으로도","선언을","선택하는","설계","설정에서","설정하는","설정하면,","설정했기","성공,","성공적으로","세트가","세트에","섹션은","소스","소스가","소스는","소스에","수","수도","수의","수행하지","수행합니다.","순서로","스크립트가","스텝","스텝은","스텝이","시간","시나리오를","시도:","시도합니다.","시작하기","시작합니다.","시작해서","시점에,","식별한","실패함.","심지어","싶으면","싶으면,","씌웁니다.","아닌","아닙니다.","아래에","아마","아주","안내하기","안되고","안에","안의","안전하게","안전한","않거나","않고","않는","않도록","않습니다.","않아도","않았기","않았으면,","않으면,","않은","않을","않음,","않음을","알고리즘은","알려주는","알려주어","알려줍니다","알려줍니다.","알리기","알릴","알아내기","알아야","암시적으로","앞에서","애플리케이션에서","애플리케이션이","어디를","어디에서","어떤","어려울","얻을","없다면,","없습니다.","에서","엔트리를","엔트리에서","여러","여부에","여전히","열거하고,","영향을","옆에","예","예를","예상되는","예제","예제가","예제는","예제를","예제에서","예제에서,","예제에서는,","오류","오류는","올라가","올라가,","옵션은","와","와일드카드가","완료.","외부","외부의","요약되어","요즘에,","위","위에","위에서","위의","위치","위치로","위치를","위치에서","위치하지","위치한","위한","위해","위해,","위해서,","위해서는,","유연함은","유의하십시오.","유의하십시오;","유저","유지하는","으로","은","을","의","의미,","의존성을","의존하는","의해","이","이는","이동","이러한","이를","이름","이름과","이름에","이름은","이름을","이름의","이름이","이번","이유는","이유를","이전","이제","이해하기","이해하는","인사이트를","인수","일련의","일반적으로","일반적인","일부","일부로","일부로써","일치하고","일치하는","일치하지","일치할","읽어보실","임의의","있거나","있게","있는","있다고","있다는","있도록","있습니다,","있습니다.","있습니다:","있습니다;","있으면,","있을","있지만,","자동","자동으로","자세한","자신의","작업에","잘","잘못된","전달됨","전달하지","전달했기","전략","전략들은","전략으로","전략은","전략을","전략이","전에","전용","전제로","전체","전통적으로,","점에","점프합니다.","점프했다는","접두사","정교한","정보는","정보를","정의","정의되어","정의로","정의를","정확하게","정확히","제공되는","제공됩니다.","제외","제외되었는지에","제외하고","제외하기","제외해야","제한되지","조건부","조회를","조회합니다:","존재","존재.","존재하는지","존재하지","종류가","주로","주목하세요.","주어지는지에","주어진","주의사항","줄","줄로","줄에","중","중에","중요합니다.","지시문이","지시합니다.","지식을","지원을","지원하는","지원합니다.","지정되어야함.","지정되지","지정하고","지정하기","지정하는","지정하는데","지정하지","지정할","지정합니다.","지정했다면)","진단할","질문","질문할","참조가","참조하는","참조하는지","참조할","찾고","찾고,","찾기","찾는데","찾도록","찾습니다.","찾았다는","찾았다면,","찾으려고","찾으실","찾을","찾을지","찾음.","처리할","첫","체인에서","체인을","최종","추가","추가된","추가됩니다.","추상","추적","추적을","출력","출력과","출력에서","출력을","출력의","출력이","캡처할","캡처함","컨트롤을","컴파일","컴파일러","컴파일러가","컴파일러는","컴파일러를","컴파일러에게","컴파일에","컴파일은","컴파일하고,","코드가","코드입니다.","클래식","클래식.","타임에","타협하지","템플릿","템플릿이","토큰을","툴이","트리를","특별한","특수","파일","파일과","파일들은","파일들은,","파일로","파일에","파일은","파일을","파일의","파일이","패키지에서","패턴","포함과","포함됩니다.","포함입니다.","포함하게","포함하고","포함하는","포함하지","포함한","포함할","포함합니다.","포함합니다:","폴더","폴더는","폴더로","폴더를","폴더에서","폴더의","프로세스에","프로세스입니다.","프로젝트","프로젝트의","프로퍼티","프로퍼티를","플래그","플래그를","플러그인과","필드","필드를","필요가","하게","하기","하나가","하나로","하나를","하나의","하는","하세요.","하위","하지","하지만,","한","한곳으로","한다고","할","할지","함수를","합니다.","합니다:","항목을","항상","해당","해당하는","해봅시다.","해석","해석.","해석되거나,","해석되고","해석되기","해석되지","해석된","해석된다는","해석될","해석됩니다.","해석은","해석이","해석하는","해석하려고","해석하여","해석할","해석합니다:","해줍니다.","현재","형태가","호출","호출해","호환성을","혹은","확인.","확인하기.","확장자","활성화하면","활용하여"],"pages/Declaration Merging.html":["\"\";","\"./map\";","\"./observable\"","\"./observable\";","\";","\"canvas\"):","\"cyan\")","\"div\"):","\"hello,","\"magenta\")","\"span\"):","\"white\")","\"yellow\")","\"선언","#14080을","'네임스페이스","'선언","()","(basic","(colornam","(disallow","(f)","(global","(introduction)","(merg","(modul","(x:","+","...","//","1,","10};","2,","4","5,","6,","=","==","=>","album","album.albumlabel;","albumlabel","anim","animal):","animal;","animalshavemuscl","animalshavemuscles()","animals의","animal의","any):","array","array.prototype.toobserv","augmentation)","blue","box","box:","buildlabel","buildlabel(name:","buildlabel.prefix","buildlabel.suffix;","cat):","cat;","class","classes)","classes,","clone(animal:","cloner","color","color.blue;","color.green","color.green;","color.r","concepts)","console.log(buildlabel(\"sam","consumer.t","createelement(tagname:","declar","default","default는","doanimalshavemuscl","doanimalshavemuscles()","document","document의","dog","dog):","dog;","element;","enum","enums)","export","function","functions,","global","green","havemuscl","havemuscles;","havemuscles는","havemuscles이","height:","htmlcanvaselement;","htmldivelement;","htmlelement;","htmlspanelement;","import","import/export의","interfac","interfaces)","javascript","javascript는","javascript에서","javascript와","label:","leg","map(f:","map.t","merges)","mixcolor(colorname:","modul","name","namespac","namespaces)","number;","numberoflegs:","o.map(x","o:","observ","observable.prototype.map","observable.prototype.map에","observable.t","observable;","prefix","red","return","scale:","sheep):","sheep;","smith\"));","string","string)","string):","suffix","t)","toobservable():","true;","typescript는","typescript만의","typescript에서","typescript의","u):","width:","x","x.tofixed());","zebra","{","{height:","}","가능합니다.","가시성","가장","가져와","가지","가진","각","각각의","간단한","값","값을","갖게","갖는","갖습니다.","같습니다:","같으므로,","같은","같을","같이","개념들","개념으로의","개념은","개념을","개념이","개든","개별적인","개의","객체를","객체의","것과","것에","것에도","것으로","것은","것을","것입니다.","것처럼","결과","결과물은","결과물을","결합합니다.","경우","경우)인","경우,","고급","고유하지","고유해야","공유하는","관리되는","구분된","구현은","구현해놓지","규칙엔","규칙은","그","그러나","그러나,","그룹","그룹의","그중","기계적으로","기능을","기본","기본적인","기존","기존의","기타","나중에","나중의","남겨놓겠습니다","내보내지","내보낸","내부","내부에","내부에서","내에서","내용은","네임스페이스","네임스페이스,","네임스페이스가","네임스페이스는","네임스페이스도","네임스페이스를","네임스페이스에","네임스페이스에서만","네임스페이스와","네임스페이스의","높은","는","다","다른","다음","다음과","단일","단지","대체하려면,","대한","대해","더","데에","도움이","독특한","돌아가서,","동일하게","동일한","동작하지만,","되지","된","될수록","됩니다.","두","둘","들어,","들어:","따라야","때","때문에,","또","또한","뜻합니다.","레벨에서","리터럴","리터럴의","마지막으로","마찬가지로,","마치","만","만약","많아집니다.","많은","말은,","매개변수가","맨","멤버가","멤버는","멤버를","멤버에","멤버의","멤버일지라도,","명심하세요:","명확하게","몇","모델링","모델은","모두","모듈","모듈을","모든","목록의","몫으로","못합니다.","무슨","문을","문자열","믹스인","및","바인딩","방법으로","방법을","번째","번째에","범위에","변수","변수와","별칭","병합","병합\"은","병합'","병합:","병합되며,","병합되어","병합되지","병합된","병합됩니다.","병합됩니다:","병합은","병합을","병합의","병합이","병합입니다.","병합하기","병합하는","병합하는지","병합하려면,","병합할","병합합니다.","보강","보강과","보강된","보강에","보강을","보강할","보존하며","본론으로","볼","부분에서는","비","사용법","사용하여","사항을","살펴보겠습니다:","상관없습니다;","새로운","생성","생성된","생성하기","생성한","생성합니다.","생성합니다:","선언","선언과","선언된","선언만","선언에","선언에는","선언으로","선언으로부터","선언은","선언을","선언의","선언이","설명하는","설명한","설명합니다.","세","섹션에서","섹션을","소개","수","수도","수준에서,","숙제","순서를","시그니처는","시그니처라는","시그니처에","심벌을","아닌","아닙니다.","아래의","안전하게","않는","않다면,","않습니다.","않아서,","않았습니다","않은","않은)","않지만,","알려줄","알지","액세스","어떻게","언어의","업데이트하여","없다는","없습니다","없습니다.","없으며,","엔티티를","여러분을","여러분의","여전히","열거형","열거형과","열거형을","열어줄","예로","예를","예시를","예약어입니다","예외가","예제에서","오류,","오류를","오버로드","오버로드하는","올라오게","요소는","우리는","우선순위를","원래","원래의(병합되지","원본과","위로","위의","위치에서","위치하는","위한","위해","위해선,","유니언이","유연합니다.","유의하세요.","유지하지만,","유형은","의미합니다.","이","이곳에서","이는","이들이","이러한","이를","이름에","이름으로","이름은","이름을","이름의","이름이","이름이지만","이미","이상의","이외에도,","이점이","이해하는","이해하면,","이해한다면","이해할","이해해야","익숙할","인터페이스","인터페이스가","인터페이스는","인터페이스들이","인터페이스로부터","인터페이스를","인터페이스에","인터페이스와","인터페이스의","일반적이고","일부는","일어나는지","일으킵니다.","일이","있는","있습니다.","있습니다.(해당","있습니다:","있을","자세한","자체는","작업을","잘","장난감","전역","점으로","접근할","정도로","정보를","정의가","정의는","정의들이","정의로","정의할","정적","제공합니다.","제한","제한하지","존재합니다.","종류","좋은","중","지원하지","지정된","지정자와","참고하세요)","참고하세요.","처리합니다.","첫","최상위","최종","추가하여","추가할","추상화","출력된","출발점이지만,","컴파일러가","컴파일러는","컴파일러에게","클래스","클래스,","클래스는","클래스를","클래스에","클래스입니다.","타입","타입(예:","타입,","타입을","타입의","타입이어야","통해","특별한","특수","파일에서","패치","패치만","패턴","패턴을","표기법을","표시되며","프로그래밍","프로퍼티를","필요가","하나의","하며,","한","할","함수","함수,","함수가","함수를","함수만","함수에","합니다.","합쳐진","합치도록","해석됩니다.","해야","허용되는","허용되지","현재로선,","형성됩니다.","형태로","형태를","혹은","확인할","확장됩니다.","확장시켜야","확장하는","확장할","후","후에"],"pages/JSX.html":["\"./mycomponent\";","\"bar\"","\"bar\"].map(funct","\"bar\"].map(i","'foo'의","'mycomponent'의","'some","'{bar?:","'{foo?:","(","()","(attribut","(basic","(children","(class","(embed","(factori","(fc)","(function","(i)","(intrins","(introduction)","(prop:","(props)","(react","(tabl","(the","(type","(typescript","(valu","(기본값은","(함수형",")","*","*/","*참고:","+","...",".j",".jsx",".tsx",".ts와","/","/*","//","///","1000}","2.3부터,","2.8","2})}","2};",":",";","=","=>","@jsx","[elemname:","anothercomponent(prop:","any;","assertion)을","as라는","babel)에","badprop","bar","bar;","bar?:","bar가","base","boolean","boolean}'","button","catch","checking)","children:","class","clickableprop","color:","compon","component)","componentfoo(prop:","const","contents)","context:","createelement(\"div\")으로","createelement를","customcomp","declar","div","dom","elementattributesproperti","elementchildrenattribut","elementclass","elements)","es6","expression...\"","expressions)","expr은","expr의","extend","factory)","foo","foo:","foo;","foo?:","fooprop","fooprop)","function","functions)","h.jsx를","hello","home:","homeprop","homeprops):","h로","import","integration)","interfac","intrinsicel","javascript","javascript로","js","jsx","jsx.element","jsx.element;","jsx.element[]","jsx.elementattributesproperty가","jsx.elementattributesproperty를","jsx.elementattributesproperty에","jsx.elementchildrenattribute는","jsx.elementchildrenattribute를","jsx.elementclass는","jsx.elementclass에","jsx.element에","jsx.element의","jsx.intrinsicattribut","jsx.intrinsicclassattribut","jsx.intrinsicel","jsx.intrinsicelements에","jsx.intrinsicelements에서","jsx.intrinsicelements의","jsx:","jsxfactori","jsxfactory에","jsx는","jsx를","jsx에서","jsx의","key.","mainbutton(prop:","mycompon","mycomponent();","mycomponent가","myfactoryfunct","myfactoryfunction()","myfactoryfunction();","name:","namespac","nativ","native라는","new","notavalidcompon","notavalidfactoryfunction()","null);","number","number;","operator)","optionalprop?:","pragma","preact","preact.h","preact.h(\"div\",","preserv","preserve,","prop","prop'은","props:","props;","propstyp","props나","react","react.compon","react.createelement(\"div\")","react.createelement(\"div\")과","react.createelement(\"mycomponent\")가","react.createelement(기본값)로","react.createelement)","react.createelement를","react.jsx를","react로","react와","react의","ref","render()","render:","require(\"preact\");","requiredprop:","requiredprop은","requiredprop이","result","return","sfc","side:","sideprop","sideprops):","span)","statelesscomponent은","string","string;","string]:","string}'","string});","string},","tsconfig.json","ts는","type","type)","typescript","typescript는","unknown","unknownprop은","usage)","var","void","world","x","x:","xml","y:","{","{\"thi","{[\"foo\",","{i","{name:","{props.children}","{this.props.children}","{this.props.foo}","{value:","{}","{};","{}이지만,","|","}","})","})}","})로","};","↥","가능하도록","가능합니다.","가능합니다:","가능해야","가지","가지의","각각","간단하게","간에","간주하지","감싸","값","값의","갖게","갖습니다.","같습니다:","같은","같이","객체인","검사","검사,","검사되지","검사를","검사에는","검사하기","검사할","검색할","것","것과","것은","것을","것입니다.","결과","결과는","결과물은","결과물의","결과적으로","결정되면,","결정됩니다.","결정하는","결정합니다.","결정해야","결합하여","경우","경우,","경우엔","과","과부하","과정도","과정이","괄호","괄호를","구문과","구문은","구문입니다.","구별할","구별합니다.","구현도","구현에","규칙을","그","그대로","그러나","그렇지","기반","기본","기본적으로","기준):","꺾쇠","나눌","나아가서,","내의","내장","내장된","내장형","내재적으로","네임스페이스(타입","네임스페이스로","네임스페이스를","누락됨","는","다르게","다르지만","다른","다릅니다.","다시","다음","다음과","다음의","다음처럼","단계(예:","단계에서만","단언(type","단언과","단언을","단언하기","단언합니다.","단일","대문자로","대신","대체","대한","대해","더","데에","도입했습니다.","돌아가기","동일하게","동일하지만,","동일한","동일합니다.","동작하지만,","동작합니다.","동작합니다:","되고,","된다는","될","됩니다.","두","들면","들어","들어:","등)가","등장했습니다.","따라","따라서","때","때,","때문에","때문에,","떠올려","또는","또한","를","리액트를","리액트에서","리액트에선","리액트와","만든","만약","매개변수","매개변수는","먼저","명령","명령줄","모두","모드","모드는","모드들은","모드를","모드와","모든","목차","무상태","무상태로","문법","문자열","문자열로","문자열을","문자열이","문자열이어야","문제가","미치며,","미칩니다.","및","반면,","반환","반환된","받지","방법이","방출","배열이","배열이나","버전은","버전의","번째","번째로","변수","변환","변환되어야","변환의","변환이","별칭인","보고합니다.","복잡합니다.","볼까요:","부터","블랙박스입니다.","사용","사용되지","사용됩니다.","사용법","사용을","사용자","사용자가","사용하거나","사용하기","사용하는","사용하도록","사용하려면","사용하여","사용할","사용합니다.","사용해","사용해야","사이에","삽입하는","새로운","생성되는","생성될","생성됩니다:","생성자","생성자이고","생성하여,","생성할","서로","선언되어야","선언을","선택된","선택적","선택적이어야","설정이","설정할","설정했다면,","성공","성공,","성공적으로","세","소개","소문자로","속성","속성,","속성에","속성은","속성을","속성의","속성처럼","수","수도","수정하여","숫자로","쉽게","스코프에","스프레드","시그니처","시그니처(있는","시도합니다.","시작하고","시작합니다.","식별자(data","식별자가","식별자로","실패할","쓰입니다.","아니기","아닌","아닙니다.","않는","않는다면,","않습니다.","않았기","않으며,","않으면","않으면,","않을","않음","알","알고","알려져","알아야","약간","어느","어떻게","얻었지만,","없다면,","없습니다.","없어도","없으므로","없으므로,","에서","에서,","연산자","연산자는","연산자로","연산자를","영향을","예를","예시는","예시에서","예제에서","오류","오류,","오류로","오류를","오버라이드","오버로드","옵션에서","옵션으로","옵션을","요구합니다.","요소","요소(예:","요소,","요소는","요소를","요소에","요소와","요소의","용어를","위","위로","위의","위한","위해선","위해선,","유사하게,","유지한다는","유지합니다.","유형에서,","유형의","유효한","은","을","의","의미는","의한","이","이는","이라는","이런","이를","이름에서","이름은","이름을","이름이","이상","이유로","이전에","이해하기","이해해야","이후","인기를","인덱서를","인라인","인수가","인수로","인스턴스","인터페이스","인터페이스가","인터페이스는","인터페이스를","인터페이스에","인터페이스에서는","인터페이스의","일반적으로","일반적으로는,","일부를","일으킵니다.","임베딩,","입력","있는","있다면,","있도록","있듯,","있습니다","있습니다.","있습니다:","있어야","있으며,","자식","자식에","자식은","자식의","자신의","작성하는지","작성할","작업을","잘","적절하게","적절한","적합한","전달되는","전에","전역","전역입니다.","점은","점이","정보)에도","정보를","정의","정의되어","정의됩니다.","정의하는","정의하는데엔","정의합니다.","제공되지","제공됩니다.","제공할","제네릭","제네릭의","제외하고).","제한할","조금","조회되어야","조회됩니다.","존재하지","종류의","주석","주석을","줄","중","중괄호({","중요합니다:","지원됩니다.","지원합니다.","지정","지정되지","지정하려고","지정할","지정합니다.","직접","진행되면,","진행되어","집합을","쪽으로든)에","차이점에","참고:","참조할","찾을","첫","최근","추가","추가적으로,","추가적인","취급하지","컴파일러","컴파일러는","컴파일하는","컴포넌트","컴포넌트(sfc)로","컴포넌트는","컴포넌트로","컴포넌트를","컴포넌트에","컴포넌트의","코드는","큰","클래스","클래스라면","클래스의","클래스형","타이핑","타이핑을","타입","타입과","타입도","타입에","타입에서","타입으로만","타입은","타입을","타입의","타입이","타입이라는","타입입니다.","태그","태그에","통한","통합하기","통해","특수","특수한","특정","특정한","파일","파일별로","파일에서","파일의","팩토리","팩토리(jsx","팩토리가","팩토리는","포함하기","표현식","표현식에서","표현식으로","표현식을","표현식의","프레임워크","프레임워크를","프로퍼티","프로퍼티는","프로퍼티들이","프로퍼티로","프로퍼티를","프로퍼티입니다.","플래그","필수적인","필요가","필요하지","하며,","하지만","하지만,","할","할당","함","함께","함수","함수는","함수라면,","함수로","함수로부터","함수를","함수의","함수이므로,","함수입니다.","함수형","합니다.","항상","해결을","해당","해당합니다.","해석되지","해석에","해석을","해석합니다.","해야","허용하는","허용하지","허용합니다.","형식의","호출","혹은","화살","확인하는데","확장자","확장자로","확장자를","환경에","환경의","활성화합니다.","흥미롭게도"],"pages/Decorators.html":["\"","\",","\"compileroptions\":","\"emitdecoratormetadata\":","\"es5\",","\"experimentaldecorators\":","\"greeting\");","\"hello","\"hello,","\"new","\"override\";","\"property\";","\"reflect","\"target\":","%s\")","%s\")가","'es5'보다","'target'","'target'과","'undefined'이","'value'","(!(valu","(#메타데이터","()","(@","(@configurable)의","(@required)의","(@sealed)의","(accessor","(class","(command","(decor","(decorators)","(f∘g)(x)의","(introduction)","(javascript)","(let","(metadata)","(method","(paramet","(parameterindex","(properti","(requiredparameters)","(target)","(target,","(target:","(value:","(예:","+","//","2단계","=","===",">=","@classdecor","@configur","@configurable(false)","@enumer","@enumerable(false)","@enumerable(false)데코레이터는","@express","@f","@f()","@format","@format(\"hello,","@g","@g()","@reflect.metadata","@reflect.metadata(\"design:type\",","@requir","@seal","@sealed가","@sealed를","@valid","[];","[메타데이터]","_p0:","_p1:","_x:","_y:","any,","api에","argument.\");","arguments);","arguments.length","arguments[parameterindex]","boolean)","c","call","called\");","class","classdecorator(constructor:t)","color(value:","composition)","configurable(value:","console.log(\"f():","console.log(\"g():","console.log(new","const","constructor","constructor(m:","constructor(message:","constructor(x:","decorators)","descriptor)","descriptor.configur","descriptor.enumer","descriptor.set","descriptor.set;","descriptor.valu","descriptor.value;","descriptor:","ecmascript","emitdecoratormetadata","enumer","enumerable(value:","enumerable)의","error(\"miss","es5","es6에","evalu","evaluated\");","evaluation)","existingrequiredparameters,","existingrequiredparameters.push(parameterindex);","existingrequiredparameters:","experimentaldecor","experimentdecor","expression은","extend","f()","f():","f(g(x))와","factories)","format(formatstring:","formatmetadatakey","formatstr","formatstring);","formatstring.replace(\"%s\",","function","function)","f와","g()","g():","getformat","getformat(target:","getformat(this,","getformat이","get과","greet","greet()","greet(@requir","greeter","greeter(\"world\"));","greeting:","g을","hello","hello:","import","index)","instanceof","javascript에","line","line):","m;","message;","metadata","metadata\";","metadata)를","metadata라이브러리를","method","method()","method.apply(this,","name","name:","new","newproperti","npm","npm을","number)","number,","number;","number[]","object,","object.seal(constructor);","object.seal(constructor.prototype);","p0()","p0(value:","p1()","p1(value:","parameterindex","parameterindex:","point","point)","point;","privat","properti","property\";","propertydescriptor)","propertykey)","propertykey);","propertykey:","propertyname);","propertyname:","reflect","reflect.definemetadata(requiredmetadatakey,","reflect.getmetadata(\"design:type\",","reflect.getmetadata(formatmetadatakey,","reflect.getownmetadata(requiredmetadatakey,","reflect.metadata","reflect.metadata(formatmetadatakey,","requir","required(target:","requiredmetadatakey","requiredparameters)","requiredparameters:","return","save","seal","sealed(constructor:","sealed(target)","set","set.call(target,","string","string)","string,","string;","symbol(\"format\");","symbol(\"required\");","symbol,","t)","target","target,","this._i","this._p0","this._p0;","this._p1","this._p1;","this._x","this._x;","this._y;","this.greet","this.greeting);","this.greeting;","this.hello","throw","true","true,","tsc","tsconfig.json:","tsconfig.json에서","type","type))","type.\");","typedpropertydescriptor)","typeerror(\"invalid","typescript","typescript는","typescript에는","typescript에서","typescript와","typescript의","undefined)","undefined가","validate(target:","value);","value;","x","x()","x:","x;","y()","y:","y;","{","{}","|","||","}","};","가능하게","가능합니다.","가져오기만","가지","가지고","각","각각의","감쌉니다.","값도","값은","값을","같습니다.","같은","같이","개의","검증하는","것입니다.","결과는","결과를","결합한","경우","경우:","경우는","공식적으로","관리해야","관찰","관찰,","관찰하거나","관찰하는","교체하는","구문을","그러나","그런","기능으로","기능을","기능이","기능입니다.","기록할","기존의","기타","낮은","내보내는","내용은","는","다른","다양한","다음","다음과","다음에","다음은","다음은greeter","단계가","단순히","단일","달거나","대로","대상이","대신","대신해주지","대체하는","대한","대해","더","데","데만","데에","데이터는","데이터를","데코레이터","데코레이터가","데코레이터는","데코레이터를","데코레이터에","데코레이터에서","데코레이터와","데코레이터의","데코레이팅","데코레이팅된","도입됨에","동일하다고","된","될","됩니다.","두","들어,","디자인","따라","따라,","따라서","때","때문입니다.","때에만","또는","또는tsconfig.json에서","라이브러리가","라이브러리는","라이브러리를","라이브러리에","라이브러리의","런타임시","런타임에","로","로직은","릴리스에서","매개","매개변수","매개변수가","매개변수를","메개변수","메서드","메서드,","메서드를","메서드에","메서드에서","메서드의","메커니즘이","메타","메타데이터","메타데이터를","멤버를","멤버에","멤버의","명령줄","명령줄:","명령행","모델에서","모두","모든","목록에","무시됩니다.","무언가를","문서","및","바꾸고","바꿉니다.","바로","반환","반환하는","반환하도록","반환하면","반환하면,","방법에","방법은","방법을","방법이","방식으로","방식을","번째","변경","변경될","변수","변수를","변수에","변수와","변수의","볼","사용","사용됩니다.","사용하는","사용하면","사용하여","사용할","사용합니다.","사항이","새","색인(ordin","생각할","생성자","생성자를","생성자에","생성자와","서수","선언","선언,","선언과","선언되었을","선언되었음을","선언됩니다.","선언에","선언에서","선언을","선언의","선언이","선언입니다.","선택한","설명자","설명자(properti","설명자가","설명자는","설명자로","설명자에","설명자의","설명하는","설정해야","설치할","세","소개","수","수정","수정하기","수정할","수정합니다.","수학의","수행","수행됩니다.","수행합니다.","순서대로","순서를","스크립트","시나리오가","식은","실행되면","실험적","실험적인","싶다면","아닌","아닙니다.","아래","아래로","아래에서","아직","않습니다.","어노테이션과","어노테이션을","없고","없기","없습니다.","에","여기서","여러","예를","예와","예입니다.","예입니다:","예제는","예제를","예제에는","예제에서","예제와","오는","오버로드","옵션을","왜냐하면,","원래","원하는","위로","위에서","위해","유사합니다.","유일한","유지","유효성","이","이는","이니셜라이저를","이러한","이를","이름","이름의","이용","인수","인수로","인수와","인스턴스","인해","일부","일부가","일부로","읽습니다.","있는","있습니다.","있습니다:","있을","자세한","작성할","잘","재정의하는","적용되기","적용되는","적용되며","적용된","적용됩니다.","적용하는","적용할","적용해야","전에","접근자","접근자,","접근자를","접근자에","접근자의","정보가","정보를","정보와","정의","정의되어","정의를","정의할","정적","제공되지","제공하는","제공합니다.","제안이며","종류의","주변","주요","주입합니다.","지원을","지정된","직전에","참고","참조하십시오.","채택되면","채택하게","첨부할","첫","초기화되는","추가","추가하는","추가할","추가합니다.","출력합니다.","컨텍스트","컨텍스트(예:","컴파일러","컴파일러는","콘솔에","클래스","클래스)에서","클래스가","클래스에","클래스에서","클래스의","타임","타입","타입을","타입의","통해","특수한","특정","파일,","파일이나","팩토리","팩토리는","팩토리를","팩토리에","팩토리입니다.","평가","평가됩니다.","포함합니다.","폴리필(polyfill)을","표시하는","표준의","표현","표현식은","표현식을","표현은","프로그래밍","프로토","프로토타입","프로토타입을","프로토타입의","프로토타입입니다.","프로퍼티","프로퍼티가","프로퍼티를","프로퍼티에","프로퍼티의","필요에","필요한","필요합니다.","하려면,","하면","할","함께","함수","함수로","함수를","함수에","함수여야","함수와","함수의","함수입니다.","합니다.","합성","합성할","항목을","행일","향후","현재","형식을","형식의","호출되는","호출되면","호출됩니다.","호출됩니다:","호출하기","호출할","확인할","확장을","활성화되면","활성화하려면","활성화해야합니다:"],"pages/Mixins.html":["\"","+","...","//","////////////////////////////////////////","1000);","500);",":","=","=>","[disposable,","actiavat","activat","activatable]);","activatable을","activate()","any,","any[])","applymixins(derivedctor:","applymixins(smartobject,","basectors.foreach(basector","basectors:","boolean;","class","console.log(this.isact","constructor()","deactivate()","declar","dispos","disposable,","disposable과","dispose()","extend","false;","function","interact()","interfac","isactive:","isdisposed:","javascript","librari","merging으로","mixin","mixin을","mixin의","name));","name,","new","object.defineproperty(derivedctor.prototype,","object.getownpropertydescriptor(basector.prototype,","object.getownpropertynames(basector.prototype).foreach(nam","runtim","sample)","setinterval(()","settimeout(()","smartobj","smartobj.interact(),","smartobject","smartobject();","somewher","this.activate();","this.isact","this.isdispos","this.isdisposed),","true;","typescript에서","{","{}","}","});","가능한","각","각각","간단한","개념과","객쳬지향","것을","것이며,","것입니다.","결합을","결합하여","계층과","구현에서","구현에서,","구현이","구현합니다.","그","그러면","기능에","기능을","다른","다음으로,","대상으로","대신","대한","더","도우미","독립형","두","뒤에있는","등의","또","마지막으로","마지막으로,","만","만들기","만듭니다.","모델링","모두","믹스인","믹스인에","및","방법으로,","방식을","번째","보겠습니다.","보여줍니다.","복사되어","본","부분적인","부분클래스를","부터","빌드하는","사용을","사용하여","사항은","살펴","살펴보도록","새로운","소개(introduction)","속성을","속성이","수","수행","수행하는","스칼라","시작합니다.","실행되고","아닌","아래","알","알아보기(understand","어느","어떻게","언어를","얻었습니다.","예시","외에는","우리가","우리를","위해","유형","유형으로","의미합니다.","이것은","이것이","이들을","이후에는","익숙할","인기를","인터페이스가","인터페이스로","인터페이스에서","인해","일반적인","있습니다.","있을","있음을","자세히","작동","작동하는지","재사용","전통적인","정도의","제공해야","집중되어","처리","첫","취급하고","커뮤니티에서도","컴포넌트로","코드(code","코드는","코드를","코드에서는","클래스는","클래스로","클래스를","클래스에","클래스에서","통해서,","특성은","패턴은","피할","하겠습니다.","한다는","할","함께,","함수를","혼합(mix)할","혼합(mix)합니다.","혼합됩니다.","혼합합니다.","확장하는","확장한다는","후,"],"pages/Triple-Slash Directives.html":["\"es2015\"사용","\"es2015.d\"ts가","\"exports\",","\"exports\"],","\"files\"목록에","\"foo\".padstart(4);","\"legacy/modulea\"],","\"modulename\";","()","(errors)","(function","(preprocess","(require,","(use","(예",".d.t",".t","///",":lib","=","@types,","@types/node/index.d.ts에","@type의","[\"require\",","amd","amdmodule.j","amdmodule.t","api","c","c()","c;","class","d.t","declar","defin","define(\"namedmodule\",","define([\"require\",","dependency에","dependeni","deprec","dom","es2017.string으로","export","exports)","exports,","exports.c","file","files)","function","import","import로","input","iterable과","js","lib","lib.d.ts와","modul","modulea)","modulea.callstuff()","modulea:mytyp","name","namedmodul","nolib을","noresolv","noresolve)","noresolve가","note:","out","outfile을","r.js)와","requir","return","root","skipdefaultlibcheck를","slash)","ts","tsconfig.json","tsconfig.json에서","tsconfig.json을","tsconfig.json의\"lib\"컴파일러","type","typeroot","var","xml","{","}","})();","});","가","가장","간","갖는","갖습니다;","갖지","같습니다.","같은","검사하지","것","것과","것들의","것은","것을","것이","것입니다:","결과","결과를","경로는","경우","경우,","경우에만","과","과정과","과정에","과정에서,","과정은","권장됩니다.","그","그런","기본","기본적으로","기존","기준으로","깊이","나오는","낳을","내는","내용은","내장","넘겨주는","넘겨주면,","넘길","는","다른","단일","대상들이","대신","대한","동일한","되었습니다.","됩니다.","뒤에","들어","들어,","등).","따라서","때","때만","또는","또는symbol","또한","라이브러리(예.lib.d.ts)를","라이브러리라고","라인에","라인이나","런타임","루트","루트가","를","만들어","만약","맨","명시적으로","모듈","모듈로","모듈에","모듈은","모듈의","모든","목록에","무시됩니다;","문","문에서","문을","문제를","발생시킬","방법으로도","방식으로","번들러(예.","변경하지","변형한","보이는","보통의","볼","분석하기","비슷한","사용됩니다.","사용하거나","사용하기","사용하기에서","사용하는","사용하세요.","사용한다고","사용할","사항을","상단에서","상단에서만","새","생각하면","생성된","생성됩니다.","생성자와","선언","선언된","선언문을","선언으로","선언을","선언하려면,","선언하며;","선언합니다.","선택적으로","세부","수","수행합니다.","순서대로","순서로","순서를","쉽습니다.","슬래시","슬래시(tripl","시작합니다;","아닌","안에","않는","않는다는","않도록","않습니다.","알립니다.","앞에만","어떤","없는","여겨지며","여러","역할을","영향을","예를","오류","오류입니다.","오직","옵션과","우선으로","위치에","위치할","위한","위해","유사하게,","유사합니다.","유의하세요.","유효합니다.","을","의미도","의존성","의존성을","의존성이","의존하는","이","이것들은","이는","이런","이로","이를","이름을","이름입니다.","이전에는","이해하기","익명으로","인해","일반적인","일부로","입력","입력과","있는","있도록","있습니다.","있습니다:","자기","자동으로","자신에","작성자에게는","작성할","전,","전달/중복","전달할","전처리","전처리를","정렬하기","제공된","존재하지","주석","주석으로","주석은","주석의","주석입니다.","줄","줄의","줍니다.","중","지시어는","지시어로","지시어를","지시어와","지시어입니다.","지시자","지시합니다.","지정되면","지정된","직접","집합에서","참조","참조가","참조는","참조된","참조됩니다","참조를","참조하는","처리되고","처리됩니다.","처리하는","추가","추가되기","추가되어야","추가됩니다.","추가적인","추가하거나","추가한","추가합니다;","추가했어야","출력","출력물을","커맨드","컴파일","컴파일러","컴파일러가","컴파일러는","컴파일러에게","컴파일에","컴파일에서","코드:","타입","타입에","타입의","태그를","통과","툴을","트리플","특별한","파일","파일과","파일들은","파일만","파일에","파일에서","파일은","파일을","파일의","파일이","패키지","패키지는","패키지의","포함되어야","포함된","포함됩니다.","포함시키지","포함하고","포함하는","포함하도록","포함한","표시합니다.","프로세스에","프로퍼티를","플래그","하나에","하는","한","한다고","할당하는","함께","합니다.","해줍니다:","했습니다.","호출에","호출의","혹은","확인하세요.","후"],"pages/Type Checking JavaScript Files.html":["!(s.length","\"","\"@type\"","\"@typedef\"","\"fs\"`와","\"plunkbat\"","\"react\";","\"string\";","${p.name}...`);","%","'","'';","'@return'","'@returns'과","'a'","'b'","'john","'ok'","'rest'","'specialtype'이라는","'specialtype1'이라는","'typeof'","(!i)","(!somebody)","('any'로","('any'와","(...arg:","(array)","(casts)","(classes,","(commonj","(constructor","(function","(greeting)","(import","(in","(jsdoc","(more","(n)","(null,","(number)를","(object","(options.prop4","(pattern","(properti","(s)","(string)","(support","(test)","(unspecifi","(var","(또는","(클로저","(확장","*","*/","*/)","+","...",".j",".t",".ts의","/**","//","0","0,","0;","1","1,","1001)","1;","2","2);","2,","2.3","2;","3);","=","=>","????","@arg","@argument)","@augment","@augments)","@augments를","@callback","@callback,","@callback은","@class","@constructor","@constructor)","@constructor를","@enum","@enum은","@extend","@extends는","@param","@param과","@param은","@prop","@properti","@return","@return)","@t","@templat","@thi","@this를","@type","@typedef","@typedef,","@typedef를","@typedef와","@type{array.}","@type{array}","@type과","@type은","[];","[]로","[index]","[options.prop4]","[options.prop5=42]","[p3]","[p4=\"test\"]","[prop4]","[prop5=42]","[somebody]","[x:","[x:string]:","`export","`import","`number`에","`string`","a:","ab(){}","add1:","anormalfunction()","anormalfunction}","any)","any)를","any[]","any[])","any[]):","any가","any와","any이므로","any임","any입니다.","any입니다:","arg","argument","arguments)","array","arraylike;","assign","assign.extra","b","b)","b);","b:","b?:","bar(1);","bar(1,","bar(a,","beginningofline:","bodies)","boolean","boolean)","boolean):","boolean)}","boolean}","c","c()","c();","c(0);","c(1);","c(data)","c.count","c.d","c.prop","c.prototype.initi","c.prototype.method","callbackforlater(e)","calls)","check","checkjs를","class","classes)","clause)","closur","closure의","commonj","compon","console.log(\"hi!\");","console.log('hello","console.log(`walk","console.log(a","const","constructor()","constructoronly는","constructorunknown의","c는","c를","c의","data","declar","default","default)","doc","docs처럼","document.queryselector(selector);","doe';","dom","e","element.dataset.mydata","empti","ended)","enum","equival","es2015","es2015에는","examples)","export","exports와","extend","fals","false;","fc","fn10(p1){}","fn6;","fn7;","fn9(p1)","foo","foo();","foo(i","foo.l.push(\"end\");","foo.l.push(foo.i);","foo.prototype.sayhi","fs","fs.readfilesync(f);","function","function()","function(){};","function(f)","function(param1){}","functions,","getter,","greet","html","id(x){","id:","ignore를","import","import(\"./a\").pet","import(\"./a\").x","import는","import로","import를","index?:","infer","information)","initail","initi","j","javascript","javascript는","javascript에는","javascript의","jsdoc","jsdoc)","jsdocstat","jsdoc을","jsdoc의","jsx의","k","key","known","k는","liter","math","math.random()","method()","method2()","methodonly는","methodonly의","modul","module.export","module.exports.readfil","multipli","myarrow","mycompon","myelement","mypet.name;","mypet;","n","n,","namespaces)","nas;","nds;","new","nocheck","noimplicitany,","noimplicitany는","non","normal;","ns","ns.c","ns.const","ns.func","ns;","null","null)","null,","nullability는","nullabl","nullable;","nullable이","null이","number","number)","number=","number]:","numberorstr","number|undefined에","number}","number}}","number}타입엔","number는","obj","obj.b","object","object)","object}}","object나","object를","ok","open","option","options.prop1","options.prop2","options.prop3","options.prop5;","outer()","outer.inn","p","p1","p1.join();","p2","p2,","p3,","p4){","p;","param","param1","paramet","parseint(e)","pet","predic","promise((resolve,","promise;","promisedstring;","prop1","prop1:","prop2","prop2:","prop3","prop3?:","props와","ps(){}","question;","react.component는","readfile`과","references)","registerclass(c)","reject()","reject)","render()","requir","require(\"./a\").x;","require(\"fs\");","result","return","right;","s","s.length","s;","savingcomments:","sawasterisk:","sayhello();","sayhello(somebody)","sb;","sbn2;","sbn;","seriou","serious():","seriousaliz","seriousalize(key,","set","setter에서만","somebodi","somebody);","somefunc","someobj","sortableset","space)에","special(options)","specialtyp","specialtype1","specialtype1의","specialtypeobject1;","specialtypeobject;","specialtype과","specialtype의","star;","state라는","strictnullcheck","strictnullchecks:","strictnullchecks이","string","string,","string]:","strings.","stringsstringstrings(p1,","stringtonumber;","string}","string을","sub1:","sum(/*","supported)","t","t,u,v","test","this.clientheight","this.constructoronli","this.constructorunknown","this.count;","this.i","this.initialize(data);","this.l","this.methodonli","this.prop","this.props.b;","this.props의","this.siz","this.yi","this는","this의","todo","total","true","tsconfig.json이","type","types)","typescript","typescript는","typescript에","typescript와","typescript의","undefin","undefined,","undefined;","undefined}","undefined가","undefined나","undefined로","us","usejsdoc.org에서","var","var9;","w,x","walk(p)","win;","wrong;","x","x.push(\"string\");","x.push(1);","x:","x;","x는","y","y.push(\"string\");","y.push(1);","{","{!number}","{(data:","{(s:","{(string","{*}","{...number}","{...string}","{?number}","{?}","{a:","{a:number}에","{anormalfunction}","{array.}","{array}","{boolean}","{component}","{function(number):","{function(string,","{function}","{htmlelement}","{k}","{number","{number=}","{number[]}","{number}","{object.}","{object}","{pet}","{predicate}","{promiselike}","{seriousalizable}","{set}","{specialtype1}","{specialtype}","{string","{string=}","{string}","{test.a.charat(0)};","{typeof","{t}","{window}","{{","{{a:","{{new(...args:","{}","{};","|","||","}","})();","});","};","}}","}와","가능","가능케","가능한","가정하는","가져야만","가져올","가지","가진","가질","각","간단한","간주됩니다.","간주합니다.","값","값들의","값을","값의","갖게","갖는","갖도록","갖습니다.","같습니다.","같은","같음","같음)","같이","객체","객체.","객체가","객체를","갯수가","건너뛸","검사","검사가","검사는","검사되므로,","검사를","검사와","검사의","검사하는","것","것들을","것에","것으로","것은","것을","것이","것이든","것이라도","것이며","것입니다.","것입니다:","것처럼","결과","결과를","결합하여","경우","경우,","경우가","곳이","공간(valu","과는","과정은","관용적입니다.","괄호가","괄호화된","구문","구문)","구문).","구문으로","구문은","구문을","구문이","구문적으로","구성은","귀찮은","규칙","규칙에서","규칙은","그러나","그렇지","그리고","기반으로","기본","기본값을","기본적으로","기초","꽤","나은","나타내는","내부에서","내용은","너무","넘길","넣어","네임스페이스","네임스페이스를","네임스페이스입니다.","놀라운","누군가의","느슨함","는","다뤄지도록","다르게,","다르며,","다른","다릅니다:","다양한","다음과","단순하다는","단순히","단일","닫힌","달리,","달아","대게","대괄호로","대부분의","대신","대하여","대한","대해서만","더","덕분에","데에","동일","동일하며","동일한","동일합니다.","동작과","동작은","동작합니다.","동작합니다:","동적으로","되도록","되어야","된","될","됨","됩니다.","두","둘러싸서","들면:","들어,","들어:","들어갈","등)는","등록할","등의","따라서","때","때,","때때로","때만","때문에,","또는","또다른","또한","라인의","리터럴","리터럴과","리터럴과는","리터럴에","리터럴은","리터럴을","리터럴이어야만","리턴","마찬가지로,","마치","만들","많은","많음","매개변수","매개변수(예:","매개변수.","매개변수가","매개변수는","매개변수를","매개변수보다","매개변수의","매핑하는","맵","맵(maps)으로","메서드","메서드,","메서드를","메서드에","멤버가","멤버는","명시되어","명시되지","명시적으로","명시적인","명시할","몇","모두","모듈","모듈에서","모든","모르거나","목록은","목록의","목록입니다.","못하는","무상태","무시할","문자열","문자열과","문자열이","물론,","물음표","및","반대로","반면,","반환","발생","발생할","방법에","방법으로","방법은","방법이","방식으로","배열","버전에서는","번째","번형도","변경할","변수","변수나","변수에","별칭","보고를","보고할","보다","보여줄","복잡한","본문","본문에서","본문을","본문의","부분에서","부분의","부여합니다.","부족하여","불리언","불리언(boolean)에는","불행하게도,","붙여야","비슷한","비슷합니다만,","빈","사용","사용:","사용되는","사용됨.","사용으로부터","사용하고","사용하는","사용하면","사용하면,","사용하세요.","사용하여","사용하여,","사용하지","사용하지만,","사용할","사용해","사용했습니다.","사항","사항을","사항이라는","사항임","상대적인","새","새로운","생성","생성자","생성자가","생성자에","생성자에서","생성하는","생성하지","생성할","선언","선언된","선언될","선언에","선언에서도","선언으로","선언을","선언의","선언할","선택","선택적","선택적으로","선택적인","선택할","설명하고","설명하는","설명한","설명합니다.","설정","설정되지","설정할","성공","성공,","소스가","속하지","수","수단이","수도","숫자","숫자를","시그니처)을","시그니처를","시스템과는","식별되지","쓰일","아니라","아닌","아닐","아래를","아래에","아래의","아직","안","않거나,","않고","않는","않는다는","않다면,","않습니다.","않습니다:","않았다면,","않은","않을","않음","알","알려진","알아낼","알아두세요.","암묵적으로","앞","앞서","앞에","앞엔","앞의","어떠한","어떤","엄격한","없는","없다는","없습니다","없습니다.","없었기","없으며","없으므로,","없음","에러를","여기엔","여러","열거형과는","열린","예를","예시:","예시를","예외입니다.","예제들","오류","오류,","오류:","오류가","오류를","오브젝트라면","오브젝트를","와","완화됩니다;","요소를","우선시한다는","원래의","원본","원본에","위에서","위의","위치를","유니언","유사","유의하세요.","유의하세요:","유일한","유추할","유형","유형과","유형의","은","의미가","의미는","의미와","의미합니다.","이","이곳에서","이는","이니셜라이저(initializer)를","이니셜라이저는","이니셜라이저에","이러한","이를","이름","이름에","이름을","이름이","이상의","이전","이전에는,","이전의","이해할","이해합니다.","이후엔","인덱스","인사말","인수는","인수로","인수를","인수의","인스턴스로만","인식됩니다.","일","일부","일으킨다는","일으킬","일회성인","읽기","임의의","입력하기","있는","있다면,","있더라도","있습니다.","있습니다:","있습니다;","있으며;","있을","있음","있음.","있지","자세한","작동하지","작동한다는","작업할","작용합니다.","잘","적은","전역으로","전용","전자에","절에","절에서","점에","점을","접미사","접미사는","정당한","정보로","정보를","정의되어","정의되지","정의된","정의할","정적","정확히","제공할","제공합니다:","제네릭","제안이","제약","제외하고;","제한됩니다:","조건을","조금","조합이","조회하고","존재하는","종류의","주목할만한","주석을","주어진","줄에","중","중첩된","중첩하는","즉시","지원","지원되는","지원되지","지원됩니다.","지원보다","지원은","지원하며","지원합니다.","지정되지","지정된","지정에","지정하는","지정하려면","지정하여","지정하지","지정할","지정합니다:","차용합니다.","차이점을","차이점이","참고하세요.)","참조(원래","참조를","참조에서","참조하는","첫","초기화된","초기화하는","초기화하더라도","추가될","추가됩니다.","추가하는","추가하여","추론","추론된","추론하지","추론할","추론합니다.","추론합니다만,","추론해볼","취급됨)","취급됩니다:","캐스트","캐스트(cast)","캐스트를","컨텍스트가","컴파일러가","컴파일러는","컴포넌트에서도","코드는","코드를","코드의","콤마","큰","클래스","클래스,","클래스는","클래스를","클래스에","클래스에서만","클래스엔","클래스와","클로저","클로저의","타입","타입(인덱스","타입,","타입과","타입까지","타입도","타입만","타입에","타입에는","타입으로","타입으로는:","타입으로의","타입은","타입을","타입의","타입이","타입이든","타입인","타입임","타입입니다.","태그","태그(@async","태그는","태그로","태그를","태그의","통해","특정","특화된","파일","파일과","파일에","파일에는","파일에서","파일에서,","파일에서는,","파일에선","파일은","파일의","파일처럼","패턴","패턴들","패턴을","포맷을","포함하는지,","표시가","표시를","표시와","표시할","표시합니다.","표준","표준과는","표현","표현식","프로퍼티","프로퍼티가","프로퍼티는","프로퍼티는,","프로퍼티들을","프로퍼티로","프로퍼티로부터","프로퍼티를","프로퍼티만이","프로퍼티의","플래그를","플래그와","필요가","하나)할","하는지","하는지에","하도록","하지만,","한","할당과","할당되었던","할당된","할당됩니다.","할당에","할당에서","할당은","할당을","할당할","함","함!","함수","함수(iife)","함수,","함수가","함수는","함수는,","함수를","함수와","함수의","함수처럼,","함을","합니다.","항상","해당","허용되는","허용되지","허용됨","허용됩니다.","허용됩니다:","허용합니다.","현재로서는,","형태는","형태의","호출","호출에서","호출은","호출하는","호출하면","호출할","호출해야","혹은","화살표","확인할","확장","확장하는","확장할","활성화되어","활성화되어있는","활성화되어있지","훨씬","흔히"],"pages/Utility Types.html":["\"a\"","\"b\"","\"c\"","#32964를","&","'about'","'b'가","'clean","'clear","'contact'","'contact';","'delet","'hello';","'home'","'organ","'thi","'this'","'throw","()","(example)","(introduction)","(string","(tabl","+=","...data,","...fieldstoupd","...method","...todo,","//","0","0,","0;","10;","20;","5","5);","=","=>","[(string","[]","[string,","[string]","[unknown]","[{","`bind`의","`omitthisparameter`을","a:","a?:","about:","b:","b?:","boolean;","c","class","clutter',","completed:","console.log(fivetohex());","const","constructorparamet","constructorparameters;","contact:","contents)","d","d;","data:","data?:","declar","desc.data","desc.method","description:","desk',","dx;","dy:","dy;","exampl","exclud","exclude;","extract","extract;","f1():","f1(arg:","false,","fieldstoupdate:","fivetohex:","freeze(obj:","frozen","function","function>;","home:","inact","instancetyp","instancetype;","interfac","k로","k를","k의","lib.d.ts에","m","m;","makeobject(desc:","makeobject({","makeobject의","method","methods:","methods?:","moveby(dx:","never","never)을","noimplicitthi","nonnul","nonnullable;","null","number","number)","number):","number,","number;","number[]","numbertostring(n:","obj","obj.i","obj.moveby(5,","obj.x","obj2:","obj:","object","object.freez","objectdescriptor","objectdescriptor):","omit","omit;","omitthisparamet","out","page","pageinfo","paramet","parameters(arg:","parameters;","partial","partial)","pick","pick;","prop","readonli","readonly;","record","requir","return","returntyp","returntype()","returntype;","room',","strictfunctiontypes가","string","string;","string>;","string[]","t)","t):","t)>;","t0","t1","t2","t3","t4","t5","t6","t7","t8","this.i","this.tostring(16);","this.x","thisparametertyp","thisparametertype)","thistyp","thistype;","thistype를","this타입에","title:","todo","todo,","todo.titl","todo1","todo2","todo:","todopreview","tohex(this:","tohex.apply(n);","tohex.bind(5);","trash',","type","typescript는","t에서","t의","undefined)?]","undefined를","unknown[]","unknown을","updatetodo(todo1,","updatetodo(todo:","users',","u에","void","void),","void>;","x","x:","y","y:","{","{}","{};","|","||","}","}):","});","},","};","}]","}입니다.","가능합니다.","가지","가지고","가지는","강하게","객체","객체는","객체의","것을","것입니다.","경우","경우)","공통","과","구성된","구성합니다,","구성합니다.","그","나타내는","나타낼","넘겨지는","넘어,","다른","다음","단지","대상이며","대신,","데","동시에","동작합니다.","따라서","때","때만","런타임에","로","리터럴의","마커","만드는","만듭니다.","매개변수","매개변수가","매개변수를","매개변수의","매핑시키는","메서드","몇","모든","목차","문맥적","반환","반환하지","반환합니다.","변형된","변환을","빈","사용","사용될","사용하고","사용하기","사용해야","생성된","생성자","생성합니다.","선언된","선택적으로","선택한","선택해","설정된","설정한","성공","소개","속성을","수","실패할","아닌","안에","안의","않습니다.","없습니다","없습니다.","없을","없음","역할을","예제","예제를","예제에서,","오류","오류:","올바르게","용이하게","위","위한","위해","위해선","유용합니다.(예,","유의:","유의하세요.","유틸리티","유틸리티는","유틸리티들은","유틸리티를","이","이는","이런","이미","인스턴스","인식되는","인자로","인터페이스는","인터페이스입니다.","인터페이스처럼","읽기","입니다.","있게","있고,","있는","있습니다,","있습니다.","재할당","재할당할","전역으로","전용","전용(readonly)으로","정해진","제거한","제거합니다.","제공합니다.","제외한","주목하세요.","주어진","즉","집합","집합을","참고하세요.","추론의","추출하여","추출할","추출합니다.","출처인","컴파일","타입","타입(t가","타입,","타입들의","타입에","타입에서","타입으로","타입은","타입은{","타입을","타입의","타입이","튜플","포함한","표시하는","표현식을","프로퍼티","프로퍼티가","프로퍼티는","프로퍼티들을","프로퍼티를","프로퍼티에","프로퍼티의","플래그를","필수로","하기","하는","하려고","하위","한다는","할","할당","할당할","함수","함수가","합니다.","해줍니다.","혹은","활성화되었을"],"pages/declaration files/Introduction.html":["\"don't\"s)","(\"do\"","(bi","(deep","(find","(librari","(publish","(sections)","(templates)","api","declar","dive)","example)","files)","instal","javascript","npm","npm)","npm에","structures)","typescript","typescript의","가이드는","가이드는,","가정합니다.","가지","각","간단한","감지하는","개념,","개념들을","개념을","것","것과","경우,","경우라면,","고급","고품질의","관리하는","관심","구성됩니다.","구성에","구조","구조는","기본","기존","깊게","깔끔하고","네임스페이스에","다음","대한","대해","더","동작하는","들어가기","때,","라이브러리","라이브러리의","만드는","만약","많은","말아야","맞추고","메커니즘에","몇","모두가","모든","문서를","미치는지","반드시","방법과,","방법에","방법을","배포","배포하기","배포하는","보여줍니다.","사용자들에게,","사용자를","사용할지","새로운","선언","선언을","설명합니다.","설명해","설치하기","설치하는","섹션","섹션들로","섹션은","섹션을","소개","소비","수","수정하는","숙련된","쉽게","시작점을","식별하고,","실수들은","실수들을","아직","않은","알려주기","알려줍니다.","알아보세요.","어떤","어떻게","언어","언어에","없다면,","없습니다.","여러","영향을","예제를","예제만","오류들을","올바르게","올바른","위해","위해,","유용한","의존성","이","이해하기","익숙하지","익숙해져야","일반적인","읽고","읽어야","읽으실","있는","있다고","있습니다.","있을","작성되었습니다.","작성에","작성의","작성하는","작성할","작성해야","제공하는","제공합니다.","주고,","지식이","직관적인","참고하여","찾고","찾을","초심자에","초점을","타입과","템플릿","템플릿에서는","통해","특히","파일","파일들을","파일을","파일의","파일이","패키지를","패키지에","패턴들과","패턴들의","포맷과","포맷에","포맷이","피하기","피할","필요는","하지","한다면","할","합니다.","해당","해야","핸드북을","활용하여","흔한"],"pages/declaration files/Library Structures.html":["\"","\"es6가","\"function\"","\"hello,","\"moment\";","\"node.js에서","\"object\"","\"브라우저에서","\"이름","$","$(()","&&","'b';","'cats'를","'new'","'require'","'somelib';","'x'를","(b)","(consum","(depend","(es2015,","(exampl","(footnotes)","(from","(function","(global","(identifi","(import를","(librari","(modul","(modular","(node.js)를","(overview)","(prevent","(root,","(template)","(the","(typeof","(umd나","(모듈","(아래를","(즉,","(혹은",");","*","*/","+","/*","//","///","2,","2015","3];","6,","=","===","=>","@types/mylib","['somelib'],","[1,","app","array.prototype이나","b","bar","baz.d.t","baz.j","c","c;","call","cat","catskittyset","class.d.t","class.d.ts를","code)","commonj","commonjs/node.j","commonjs와","commonjs의","conflicts)","console.log('hello!');","console.log(moment.format());","console.log(x.startswithhello());","console.log(y.reverseandsort());","creategreeting(s)","d","declar","default","defin","define(...)","define(...,","define([\"libname\"],","define,","define.amd)","define에","dependencies)","document","dom","dom이","ecmascript","es6","es6가","es6로도","es6에서는,","exp","exp();","export","export로","export를","express","express,","express는","express와","exp로","factory(require(\"libname\"));","factory(root.libname);","factory)","factory);","file","foo.d.t","foo.j","fs","function","function(s)","function(somelib)","function.d.ts.","function.d.ts을","function선언","getthing():","global","global.d.ts은","gulp,","html","impact","import","import)는","importing하는","import된","import문을","import하는","index.d.t","index.j","interfac","javascript에서","javascript의","jquery,","jquery를","kind","kittyset","layout)","librari","libraries)","library)","loadash","modifi","modul","modular","module.d.t","module.d.ts,","module.export","module.exports)","module.exports에","modules)","modules은","module에","moment","moment.j","moment.js,","moment.js에서,","moment;","mylib","mylib를","name","namespac","new","new를","node.j","node.js나","node.js에서만","plugin","plugin)","plugin.d.t","plugins)","rang","range는","request와","requir","require(\"bar\");","require(\"express\");","require(\"foo\");","require(\"fs\");","require(\"mag","require(\"moment\");","require(\"mylib\");","require(\"mylib/bar\");","require(\"mylib/bar/baz\");","require(\"mylib/foo\");","require('somelib');","requirejs는","requirejs를","require를","return","root.returnexport","s;","shims은","signatures)","somelib","somelib.thing;","string","string.prototype에","structur","template)","time\");","typeof","typescript","typescript나","typescript는","umd","umd가","umd로","unus","var","var문","window","window.creategreet","window.somenam","window가","world\"","world\";","x","x(\"hello\");","x(42);","y","{","}","}(this,","});","가능","가능/생성","가능성","가능성을","가능한","가이드는","가장","가정","가지","가지가","가지고","가지를","가질","각","각각의","각주","각주가","각주를","간단한","간단합니다.","간단히","간주되기에","감지하고","값","값을","갖지","같습니다:","같아야","같은","같이","개념을","개발자는","개요","객체(여기에서는","객체는","객체를","객체에","거의","건","검사","검사합니다.","것보다","것은","것을","것이","것입니다.","것입니다;","구별하기","구성됩니다","구성에","구애받지","구조를","구조화","구조화하는","규칙은","그","그러므로","그리고","기반으로","기존","나타낼","내에","내장","네임스페이스로","노출합니다.","높입니다.","다룹니다.","다뤄보겠습니다.","다른","다릅니다.","다음","다음과","다음은","다음을","단계입니다.","대게","대부분","대부분은","대부분의","대한","대해","더","동작하고","동작합니다.","될","들면,","들어,","등","디렉티브를","따라","따라서,","따라야","때","때)","때,","때문에","때문에,","라이브러리","라이브러리가","라이브러리는","라이브러리들은","라이브러리들의","라이브러리로","라이브러리를","라이브러리에","라이브러리에서","라이브러리의","라이브러리입니다.","런타임","런타임에","레벨","레벨에서","레이아웃","레이아웃은","레이아웃을","로더","로더로","로더에","로더에서,","로더에서는","로드되어야","로드하는","마세요","마세요!","마찬가지로","만약","많은","많이","맞추어","메서드","메서드를","멤버를","몇","몇몇","모듈","모듈)의","모듈과","모듈군","모듈로","모듈에","모듈에도","모듈은","모듈을","모듈의","모듈이","모듈이나","모듈형","목적을","무엇이든","무조건적인","문서","문서는","문서를","문서에서","문서에서는","문서에서도","문서와","미치는","바꾸는게","바꿉니다.","바닐라","반드시","반면","반영해야","반환값을","발생할","방법,","방법과,","방법에","방법으로","방법은","방법을","방지\"","방지하기","번째로,","변경되든","변경하는","변경합니다.","변수가","변수를","변수에","보고","보면,","보았다면,","보여주는","보여줍니다.","보이는","보통","본인에게","볼","불가능합니다.","불변하다고","브라우저","비슷하지만,","비슷한","빠르게","사용","사용법과","사용법은","사용을","사용자가","사용하기","사용하기\"","사용하는","사용하면,","사용하세요.","사용하세요:","사용하여","사용하지","사용한다면,","사용할","사용해서","사항에","상단에서","상응하는","상황을","새로운","생성","생성할","선언","선언문","선언에","설명하고","설명하는","설명합니다.","세","섹션에","섹션에서는","수","수정","수정합니다.","쉬운","쉬울","쉽게","쉽기","스코프","스코프에","스크립트","스크립트를","스타일","스타일로","시간에","시그니처에","시작하면","식별하기","식별하는","식별할","실제","실제로","실제로는","실행될","쓸","아닌지","안에","않고","않기에,","않는","않다면,","않습니다:","않음)에서","않지만,","알고","알려진),","어떤","어렵습니다.","엄청","없는","없는)","없습니다.","없습니다:","여러","여전히","연산자를","영향","영향\"를","예로는","예를","예제","예제들을","예제를","예제에서는","오늘날,","왜냐하면","위","위해","위해,","위험하지만,","유명","유명한","유무를","유의하세요.","유형은","의존성","의존성을","의존성이","이","이나","이는","이런","이렇게","이를","이름","이번","이상의","이에","인기","인터페이스","일반","일반적으로","일반적으로,","일반적인","읽어보세요","읽어보세요.","있고","있고,","있는","있다는","있다면","있다면,","있도록","있습니다","있습니다,","있습니다.","있습니다:","있습니다;","있어야","있으면","있으므로","있으므로,","있을","자동으로","작고","작성되어","작성되었습니다.","작성을","작성하고","작성하기","작성하는","작성한","작성할","작성합니다","작성합니다.","작성합니다:","작성해야","잘","적용되지","적용됩니다.","전에,","전역","전역에서","전역으로도","전역의","전역입니다.","전환하려는","전환할","절대","점을","접근","정의하는","정의하면,","정의한","정의할","정의합니다.","정책이","제공하는","제공합니다.","제공합니다:","존재하는","존재한다고","종류","종류를","종류의","종종","좋습니다.","주요","중","중단하지","지침을","진행할","참고:","참조).","참조해서","찾기","첫","최상위","추가하거나","추가하는","추가합니다.","추천합니다.","충돌","충돌의","충돌이","컴파일","코드,","코드나","코드는","코드들","코드를","코드에서","코드입니다.","크기가","키워드가","타입에","타입을","태그로","태그를","테스트를","템플릿","템플릿으로","템플릿을","통해)","특히","파일","파일은","파일을","파일의","파일이","패키지로","패턴","패턴에","패턴은","패턴을","패턴입니다:","편한","프로젝트","프로퍼티","프로퍼티만","플러그인","플러그인과","플러그인에","플러그인은","필요한","필요합니다.","하나","하나를","하는","하지는","하지만,","할","할당","함수로","함수를","함수처럼","합니다","합니다.","해결책은","해결할","해당되지","허용되지만,","형식을","형태를","형태의","호출","호출이","호출할","혹은","확인하세요.","확인하십시오.","환경","환경에서","환경에서는","환경에서만","활성화하기","효과를","훨씬","힌트를"],"pages/declaration files/By Example.html":["\"","\"current","\"hello","\"howdy\";","'#ff00ff'","(()","(classes)","(foo","(global","(interfaces))","(introduction)","(object","(organ","(overload","(reusabl","(the","(type","(밀리초)","(인터페이스)","(타입","*/","*code*","*declaration*","+",".alert(...)",".log(...)","/","/**","//","1","2","2));","3","4000","=","=>",">","```","```t","alert","alertopt","aliases))","api","arr:","boolean;","class","class를","color:","color?:","comput","console.log(\"half","console.log(\"th","const","constructor()","constructor(greeting:","const를","count","declar","duration:","duration?:","exampl","examples)","extend","false,","foo:","foo는","function","function)","functions)","function을","g","g.alert({","g.log({","getgreeting()","getwidget","getwidget(\"al","getwidget(43);","getwidget(n:","getwidget(s:","greet","greet(\"hello\");","greet(\"hello,","greet(g:","greet(getgreeting);","greet(greeting:","greet(new","greet(setting:","greet({","greeter","greeter(\"hello\");","greeter(\"hello,","greeter;","greeter를","greeting\"","greeting:","greetinglib","greetinglib.opt","greetinglib.options.log","greetinglik","greetinglike):","greetings\");","greetingset","greetingsettings):","greeting을","interfac","interface를","is:\"","log","logopt","makegreeting(s:","makegreeting와,","modal:","mygreet","mygreeter());","mygreeter.greet","mygreeter.showgreeting();","mylib","mylib.makegreeting(\"hello,","mylib.numberofgreetings;","mylib에는","namespac","namespace를","new","number","number):","number;","numberofgreet","numberofgreetings:","properties)","refer","result","result);","return","showgreeting():","special","specialgreet","string","string)","string):","string);","string,","string;","string을","super(\"veri","them\");","title:","title?:","true","type","types)","var","variables)","var를","verbose:","verbose?:","via","void;","widget","widget;","widget[]","widget[];","widget을","world\");","world\",","x:","{","|","}","});","가능한","가리키는","가이드는","가질","갈수록","값을","갖고","갖는","같은","객체","객체는","객체를","경고","경우","곳에나,","구조화하기","내부에","내부에,","네임스페이스를","다음의","대체로","대한","때,","또는","또한","띄울","로그","로그를","만드는","만들","만약","메서드를","명시할","문서","문서를","문자열","문자열,","문자열을","반드시","반환하거나,","반환하는","반환합니다.","받아","방법을","배열을","변수","변수가","변수를","별칭)","별칭을","보여주고,","보여주기","복잡해집니다.","블록","뿐만","사용","사용자에게","사용하세요.","사용할","상속해서","상응하는","생성자","생성하거나,","생성한","생성할","선언","선언으로","선언을","선언하기","선택적","설명하기","설명합니다.","소개","수","수를","숫자를","스코프인","시간","아니라","약칭으로","양질의","어느","예.","예상되는","예시와","예제","예제는","오버로드된","옵션을","위젯의","위해","이","인사말을","인사말의","인사말이","인스턴스를","인스턴스화해서","인자로","일부","읽기","있습니다.","있습니다:","작성되었습니다.","작성하거나","작성하는","재사용","전달할","전달해야","전역","전용이라면,","점","접근하는","정의하기","존재하는","중첩된","지금까지","창","창을","커스텀","코드","클래스","클래스는","타입","타입에","타입을","타입이나","파일에","파일을","포함합니다.","표기법으로","프로퍼티가","프로퍼티를","프로퍼티와","필수","하나의","함께","함수","함수,","함수는","함수를","합니다.","해당","호출할","혹은","후반부로"],"pages/declaration files/Do's and Don'ts.html":["\"hour\");","\"strict","\"더","\"전달하는\"","'any'","()","(a:","(callback","(data:","(done:","(function","(gener","(generics)","(option","(ordering)","(overload","(return","(use","*/","/*","//","1개","2.2","2개의",":",":)","=","=>","?","`string`","`undefined`를","any)","any):","any,","any;","any를","b:","beforeall(action:","boolean):","boolean,","b를","c:","callbacks)","checking\"","declar","diff(one:","do'","don't","done","donefn)","elapsedtim","elapsedtime:","elapsedtime?:","error,","exampl","example;","faq","fetcher","fn(myelem);","fn(x.diff);","fn(x:","function","getobject(done:","htmldivelement):","htmldivelement;","htmlelement):","interfac","javascript","javascript에서","k","k.dosomething();","meant","moment","moment().utcoffset(x);","moment;","myelem:","null","null에서","number)","number):","number,","number;","number|string)","number|string):","object","object타입을","ok","oops!","option","overloads)","paramet","parameters)","return","reverse(s:","someth","strict","string):","string,","string;","symbol","symbol,","three:","three?:","timeout?:","true","two:","two?:","type","types)","typescript","typescript는","typescript의","undefin","undefined로","undefined를","union","utcoffset():","utcoffset(b:","var","void)","void):","void,","void;","void를","wat?","x","x();","x.diff(\"something\",","x:","x의","{","}","가능한","가려져","가르킵니다.","가지","가지고","가질","값","값을","같은","객체를","거의","것보다","것은","것을","것이","것입니다,","결정합니다.","경우,","경우에만","관계없는","구체적\"이면,","구체적인","그리고","기능을","나타나기","내용은","넘어오는","노출합니다:","다르기","다른","대상의","대신에,","더","두","두지","뒤따라오는","뒤에","들어,","때","때만","때문에","때문에,","때입니다.","마세요.","마세요:","만들","만들지","말하려는","매개변수","매개변수가","매개변수는","매개변수를","매개변수만","먼저","명시적으로","모든","무시하는","문제는","문제없습니다.","박싱된","반환","발생한다는","방지","버그를","번째","번째로","분리된","분리해서","비","사람들에게","사실상","사용","사용되지","사용됨","사용자가","사용하는","사용하면","사용하세요.","사용하세요:","사용하여","사용하지","사용할","사용해","상관없다는","선택적","선택적으로","선택합니다.","소스의","수","순서","시그니처","시그니처를","시그니처의","실수로","아니라면","아마","아주","안전합니다.:","않는","않습니다.","않은","없습니다","에","에러","예를","오류.","오버로드","오버로드가","오버로드는","오버로드로","오버로드를","오버로드와","올바르게","올바름","원시형","위치에서","위치하게","위해","유니언","유의하세요.","의도였을","의도한","의미를","이","이는","이를","이유:","이유가","이유는","이전에","이전의","인수","인수가","인수로","인수를","인수만","인자로","일반","일반적으로","일반적인","일치하기","일치하는","있기","있는","있는지","있습니다.","있습니다:","자세한","작성","작성된","작성자는","작성하면","작성하세요:","작성하지","작성한","잘못된","잘못됨","적은","전달하는","전달했기","점에","정렬","정말","제공하는","제네릭","좋습니다.","좋음","중요한","중요합니다.:","지정되지","짧은","처리할","첫","첫번째","최대","추가된","코드는","코드는,","코드에서","콜백","콜백에","콜백에서","콜백은","콜백을","콜백의","콜백이","타입","타입들은","타입만","타입에","타입으로","타입은","타입을","타입의","타입이","페이지에서","필요는","필요하지","하나의","하세요.","하세요:","하지","하지만","한","할","함수","함수가","함수를","함수에","항상","허용되므로,","허용됩니다","허용됩니다.","허용합니다.","호출되지","호출될","호출을","호출할","호환성을","혹은","확인하세요.","확인하여"],"pages/declaration files/Deep Dive.html":["'./foo';","(ad","(advanc","(built","(class","(definit","(enum","(interfac","(key","(namespaces)","(number","(simpl","(type","(types)","(use","(user","(values)","(값과","(네임스페이스","(또는","(클래스의","(타입은","*","+","...","...;","//","5;에서는","=","a,","a.a","a.b","a.b.c","a.b는","a.y);","a:","a;","api","api를","a는","a라는","a에","b,","bar","bar.a;","bar:","bar로","bar를","c","c.d;","c.x;","class","combinations)","combinations:","concepts)","console.log(a.x","console.log(x.count);","const,","count:","c는","c와","c의","d","deep","dive","dive)","e","export","export와","file","foo","foo.d.ts을","foo.sometyp","foo.somevar.a;","import","import)","interfac","interface)","let,","m:","meanings)","multipl","name,","namespac","namespace)","new의","number","number;","number[];","on","s","sn","sometyp","sometype과","somevar:","somevar는","string)으로","string;","string;)","string;)에는","theory:","type","typescript","typescript의","umd)","us","var","x","x.z","x:","x라고","y","y:","y를","z","z를","{","|","}","})","};","}와","가리키는","가이드를","가이드에서는,","가져온다는","가지","가지고","가지를","가질","각","간단한","값","값과","값에","값으로","값은","값을","값의","값이","값일","같도록","같은","같이","개념을","개의","객체","객체에","걸쳐","것","것은","것을","것입니다.","결합","결합될","결합을","결합할","경우","경험","계층에","고급","과하게","관련되어","구별은","구조","규칙은","그","그리고","기회입니다:","까다로울","나온","나타내는","내보내거나","내부","네임스페이스","네임스페이스는","네임스페이스라는","네임스페이스로","네임스페이스를","네임스페이스에","네임스페이스에서","네임스페이스와는","노출","노출하는","눈치챘을","다","다르기","다른","다릅니다.","다시","다양하기","다양한","다음","다음,","다음과","단,","대상의","대한","대해","도구를","도입됩니다:","독립적입니다.","동작을","동작의","동작합니다.","동작합니다:","된","두","둘","둘은","둡니다.","들어","들어,","따라","때","때까지","때문에","때문입니다)","때문입니다.","또는","또한","라이브러리에","런타임","를","마지막으로","마찬가지로","만드는","만듭니다.","만듭니다:","말하자면,","매우","먼저","멤버를","명명된","명확하게","명확하게하기","모듈","모듈을","모든","목록에서","무엇인지","미묘하지만","밀접하게","방법은","방법을","방식에","방식으로","번째","법칙은","별칭","병합을","보겠습니다.","보다","보이지만,","복잡한","분석","분해할","불리는","블록은","비슷하게","사람이라면,","사용","사용되는지","사용됩니다.","사용에","사용자","사용하기","사용하는","사용하여","사용하지","사용해서","사용했습니다.","사용했습니다:","살펴","살펴보겠습니다.","상상할","새로운","생성된","생성자","생성자를","생성하는","생성합니다.","선언","선언(type","선언도","선언되지","선언에","선언에서,","선언은","선언을","선언이","선언할","성공","세","수","실제로","심층","아니지만,","아마도","아주","안에","안의","않는","않는다면","않습니다.","알고","약간은","어떻게","없다는","없습니다.","없었습니다.","여기서","여기서는","여기서도","여러","열거형","영리한","예는","예를","예제에서","온","옵션이","완전히","원하는","원할","위","위치","위해,","유용한","유의하세요","의미","의미를","의미할","의해","이","이란","이러한","이론:","이름","이름,","이름으로,","이름을","이름의","이름이","이름입니다.","이미","이해하여","이해할","익숙한","인스턴스","인스턴스의","인터페이스","인터페이스를","인터페이스에","일반적인","일으키지","읽고","입니다.","있고,","있는","있다고","있다면,","있습니다!","있습니다.","있습니다:","있으며","있으며,","있으면,","있을","작동","작동하지만,","작성하는","작성할","작성했습니다:","잘","저","절대로","점을","정의","정의의","정적","제공하는","제공합니다.","조합","조합:","존재할","좋은","주요","중요한","중요합니다","중점을","즉","참조하는","참조할","찾을","첫","추가","추가하기","추가할","추가합니다.","추가했습니다.","충돌을","충돌하고,","충돌하며,","충돌하지","충분히","측면(생성자","측면을","컨셉","컨테이너가","컨텍스트에","코드를","클래스","클래스가","클래스에","클래스와도","타입","타입)","타입)를","타입,","타입과","타입에","타입으로","타입은","타입을","타입의","타입이","타입이거나","특히","파일","파일에","편리합니다.","포함되고","포함됩니다).","포함하기","포함하는","표시","표현식에서","프로퍼티도","프로퍼티를","프로퍼티인","필요가","필요는","하나의","한","할","함수","함수)","함수)에","합법적입니다.","항상","해석하는","했고","현실적인","형태)","형태는","형태를","호출할","혼란스러워","확인할","흥미로운"],"pages/declaration files/Templates.html":["class.d.t","function.d.t","global","global.d.t","modifi","modul","module.d.t","plugin.d.t","templat"],"pages/declaration files/Publishing.html":["\"./lib/main.d.ts\"","\"./lib/main.d.ts\",","\"./lib/main.js\",","\"1.0.0\",","\"@types/browserify\":","\"author\":","\"awesome\",","\"browserifi","\"browserify\":","\"dependencies\"","\"dependencies\":","\"dependencies\"를","\"devdependencies\"가","\"devdependencies\"를","\"files\"","\"latest\",","\"main\":","\"name\":","\"next\"","\"types\"","\"types\":","\"types\"와","\"typescript\":","\"typings\"","\"vandelay","\"version\":","(dependencies)","(includ","(index.j","(packag","(publish","(red","....",".j","///","@type","@types)","@types/browserifi","@types안에","@types에","browserifi","browserify는","browserify와","declar","declarations)","definitelytyped에서","depend","devdependencies를","extens","extension\",","flags)","https://github.com/definitelytyped/definitelytyped에","index.d.ts이고","industries\",","javascript가","npm","npm에","npm으로","npm의","organization에","package)","package.json에","package.json에도","package.json이","publish","pull","request를","type","typescript","typescript는","typescript로","{","}","가리키도록","가이드를","가져야","가지가","가지고","각","것이","경고","경우","관리됩니다.","기대하지","기여","내용을","노출하기","다른","다시","단지","대신","더","도구를","동의어이기","되지","되지만,","됩니다.","두","들어,","들어:","따라","때문에","때문에,","때문입니다.","또한","라이브러리로","루트에","를","마세요.","만약","만약에","메인","명령줄","모든","무시됩니다.","반면에","방법은","방법을","배포","배포되었습니다.","배포하기","배포하는","배포하려면,","배포할","번들링","번들링된","번들링하거나","번째","별도의","보십시오.","복사하지","사용자가","사용하기","사용하길","사용하는","사용하면","사용하면,","사용하세요.","사용하여","사용하지","사용할","사용합니다.","사용해도","생각해봅시다.","생성하세요.","선언","선언과","선언을","설치해야","섹션","섹션을","수","시간입니다.","쓰는","쓰지","아니라","안에","않기","않는다면,","않아도","않았다면","알맞게","애플리케이션을","없습니다.","여기에서,","역시","옆에)","예를","왜냐하면","위해","유지하고","의존성","의존성들을","의존성에","의존성은","의존성을","의존성이","의존적이라면:","의존적인","의존하세요.","이","이름이","이유로,","이제","일치하게","있는","있는지","있다면,","있습니다.","있습니다:","있으면","자동으로","자세한","작성되어","작성되었다면","작성되지","작성된","작성한","작성했고","작성했으므로,","전달해야","정의가","제출하세요.","좋습니다.","지침","직접","찾을","첫","추가할","추가해야","크게","타입","파일","파일에","파일은","파일을","파일이","패키지가","패키지는","패키지들은","패키지들을","패키지로","패키지를","패키지에","패키지와","패키지의","패키징되기","패키징하기","패키징하지","페이지에서","포함하고","포함하기","표시해야","프로퍼티는","프로퍼티로","프로퍼티를","프로퍼티에","플래그","플래그를","필드는","필요가","하기","하세요.","함께","합니다.","합치지","항상","해당","확인하세요."],"pages/declaration files/Consumption.html":["\"","\");","\"lodash\";","(consuming)","(downloading)","(searching)","*","2.0","2.0에서는","20,","@type","@types/","@types/lodash","_","_.padstart(\"hello","consumpt","definitelytyped의","https://aka.ms/typ","import","instal","install을","lodash를","lodash와","npm","publishing에서","save","typescript","typescript!\",","가","가져오는데","가지를","같아야","같은","개발자가","걸","것은","것이","경우,","기여","기여하고,","내용은","다운로드","다음","대부분의","대한","대해","데","데로","도구는","도움을","들어,","또는","라이브러리에","라이브러리의","를","만약","명령어로","모두","모듈","모듈을","및","방문해","번만","변수","별","붙어야","사용하고,","사용하기","사용하지","사용할","상의","선언","선언에","선언을","선호하는","설명한","설명합니다.","설치할","세","수","수행하면,","쉬워졌습니다.","않는다면,","않습니다.","앞에","어떻게","어려움","언제든지","얻고,","얻는","없는","없다는","없이","예를","유의하세요.","이","이는","이를","이름과","이름은","이미","이상에서","이외의","있고","있다면,","있습니다.","자세한","적용됩니다.","전역","정확하게","줄","지침","참고:","참고하세요.","찾고자","찾기","찾는","찾으세요.","충분합니다.","코드에","타입","파일을","파일이","패키지","패키지를","패키지에","페이지를","페이지에서","포함되어","필요는","필요시","필요하지","하고","하는","하는지","하지만","하지만,","한","합니다.","항상","훨씬"],"pages/tsconfig.json.html":["\"**/*.spec.ts\"","\"../../built/local/tsc.js\",","\"./configs/base\",","\"./tsconfig\",","\"@types\"","\"binder.ts\",","\"checker.ts\",","\"commandlineparser.ts\",","\"commonjs\",","\"compileonsave\":","\"compileroptions\"","\"compileroptions\":","\"core.ts\",","\"diagnosticinformationmap.generated.ts\"","\"emitter.ts\",","\"exclude\"","\"exclude\":","\"exclude\"는","\"exclude\"에","\"express\"]","\"extends\":","\"files\"","\"files\":","\"files\"과","\"foo\"","\"include\"","\"include\":","\"include\"을","\"lodash\",","\"main.ts\",","\"module\":","\"node_modules\",","\"noimplicitany\"","\"noimplicitany\":","\"outfile\":","\"parser.ts\",","\"preserveconstenums\":","\"program.ts\",","\"removecomments\":","\"scanner.ts\",","\"sourcemap\":","\"src/**/*\"","\"strictnullchecks\":","\"supplemental.ts\"","\"sys.ts\",","\"system\",","\"tsc.ts\",","\"typeroots\"","\"types\"","\"types\":","\"types.ts\",","\"utilities.ts\",","&","(.ts,.d.t","(compileroptions,files,includ","(configur","(디렉토리","(또는","(모듈로","(예:","*","**/","*만",".","../../node_modules/@types/","../node_modules/@types/,","./node_modules/@types/,","./node_modules/@types/express만","./node_modules/@types/lodash","./node_modules/@types/node,","./node_modules/@types의","./typings의",".d.t",".json",".jsx).",".jsx)도",".js와",".ts,",".tsx",".tsx)","/","0개","1.8.4","2015에서",":","?","@type","@types,","[","[\"./typings\"]","[\"node\",","[]를","]","],","a.ts가","a.ts에","allowj","atom","b.ts가","b.ts는","bower_components,","compileonsav","compileonsave를","configs/base.json:","exclude는","exclude와","extend","extends)","extends는","extends를","fals","files,","foo","glob","http://json.schemastore.org/tsconfig에서","ide에","import","includ","index.d.t","index.d.ts와","index.js는","index.ts가","inherit","js","jspm_packag","node_modul","node_modules,","node_modules/@typ","p)","package.json가","project","separ","studio","true","true,","true로","tsconfig.json","tsconfig.json:","tsconfig.json에","tsconfig.json은","tsconfig.json의","tsconfig.json파일을","tsconfig.nostrictnull.json:","tsc를","tsc와","type","typeroot","typeroots를","typescript","typescript는","types을","visual","{","}","},","가진","간주됩니다.구체적으로","값은","값이","갖습니다.\"include\"와","갖습니다.지원되는","같습니다:","같은","개요","검색합니다.","것으로","것은","것을","것이","것입니다.","결합(union)을","경로","경로가","경로는","경로를","경로의","경우","경우,","경우에만","관계없이","구분에","권장하지","그","그리고","기능은","기본","기본적으로","기본적으로(위에서","기본적으로는","기본적인(위에서","기준으로","나란히","나열된","나타냅니다.tsconfig.json","다르게","다른","다음","다음과","달리).","대신","대한","덮어씁니다.","데","두","두는","들어","들어:","등의","디렉토리","디렉토리가","디렉토리에","디렉토리에서부터","디렉토리와","디렉토리의","또","또는","라인","라인에","로드된","루트","루트임을","를","리스트에서도","맞닥뜨리면","매칭","먼저","명시적으로","명심하세요","모두","모든","목록과","목록보기","목록을","무시됩니다.","문을","문자열입니다.","문자와","및","반복적으로","방법","보고","보고합니다.상속","비슷하게,","비어있을","비워","사용","사용됩니다.지원되는","사용하는","사용하여","사용한다면","사용해","상대적","상대적이거나","상세","상속","상속되는","상속받을","상속할","상위","생략될","생성합니다.","선언된","선언이","설명","설명한대로)","설정","설정되면","설정시","설정에","설정을","설정이","설정하면","속성","속성에","속성은","속성을","속성이","수","스키마","스키마는","시","시작하여","실행할","아래에","아래의","않는","않다는","않습니다.","않은","않을","없는","없습니다.","없이","여전히","예를","예제","오류를","오버라이드합니다.","오직","옵션으로","옵션은","옵션을","옵션의","와일드카드는","완전히","원래","유효한","의미합니다.","의해","이","이상과","이상의","이어지며","이용한","입니다.extends'","입력","입력에","있는","있던","있습니다.","있습니다.그러나","있습니다.기본","있으며","있지","자동","자동으로","장애와","재정의됩니다.순환성","저장","전역","전체","절대적인","점에","제외)","제외된","제외될","제외됩니다.","제외됩니다.일반적으로","제외합니다.","제외합니다.allowjs가","존재한다는","주의해야","중","중요하다는","지원됩니다.","지원하는","지정되어","지정되지","지정된","지정하는","지정하면","지정할","지정합니다.","참조","참조되는","찾을","체인으로","최상위","출력","커맨드","컴파일됩니다:","컴파일러","컴파일러는","컴파일러에는","컴파일러의","컴파일에","컴파일하는","컴파일합니다.","통해","파일","파일(.js와","파일과","파일도","파일들:","파일들은","파일만","파일에","파일에는","파일에서","파일은","파일을","파일의","파일이","패키지가","패키지는","패키지를","패키지만","패턴의","포함되며","포함되면","포함되어","포함되지","포함된","포함됩니다","포함됩니다.","포함됩니다.\"exclude\"","포함됩니다.동봉된","포함시킵니다.\"exclude\"","포함이","포함하는","포함합니다.\"outdir\"","포함합니다.node_modules/@types/*","폴더","폴더를","폴더에","폴더의","폴더입니다.","표시된","프로젝트는","프로젝트를","프로젝트의","플러그인이","필드를","필요한","필터링할","하나로","하위","한","함께)","합니다.즉","항상","해당","해석됩니다.","허용하십시오.","현재","호출하거나","호출하는","확장자","확장자만"],"pages/Compiler Options.html":["\"amd\"","\"amd\",","\"amd\"와","\"classic\"","\"commonjs\"","\"commonjs\",","\"crlf\"","\"es2015\"","\"es2016\",","\"es2017\"","\"es3\"","\"es5\"","\"es5\",","\"es6\"","\"es6\",","\"es6\"/\"es2015\",","\"es6\"와","\"esnext\".","\"esnext\".►","\"esnext\"는","\"lf\"","\"node\"","\"none\",","\"preserve\"","\"preserve\".","\"react\"","\"react.createelement\"","\"system\"","\"system\",","\"system\"만","\"umd\",","\"use","\"utf8\"","#1232","#2577","(\"ts.transpilemodule\"과","(us):","(공통","(기본값),","(예.","(윈도우)","(유닉스).\"","(인코딩","(특정","*/",".d.t",".j",".map",".tsx","/*!로","/**","0","8",":","===","?","@intern","@types,","[1]","[2]","__extends,","__extends와","__rest,","__spread에","allowj","allowjs에만","allowjs와","allowsyntheticdefaultimport","allowunreachablecod","allowunusedlabel","alwaysstrict","alwaysstrict,","any만","baseurl","baseurl을","bivari","boolean","br","charset","check","checkj","chinese:","cn","const","copi","createelement와","cs","czech:","d","de","declar","declarationdir","default","deprec","destructur","diagnost","disablesizelimit","dom","dom,es5,scripthost","dom,es6,dom.iterable,scripthost","dom.iter","downleveliter","ecmascript","emitbom","emitdecoratormetadata[1]","emit을","en","english","enum","es","es2015","es2015.collect","es2015.cor","es2015.gener","es2015.iter","es2015.promis","es2015.proxi","es2015.reflect","es2015.symbol","es2015.symbol.wellknown","es2016","es2016.array.includ","es2017","es2017.object","es2017.sharedmemori","es2017.typedarray","es3를","es5","es5:","es6","es6:","es7","esnext","esnext.asynciter","esnext.promis","experimentaldecorators[1]","export가","fallthrough","fals","file","files].","for..of,","forceconsistentcasinginfilenam","fr","french:","german:","h","h.","help","importhelp","imports를","init","inlinesourc","inlinesourcemap","input","isolatedmodul","italian:","iter","ja","japanese:","javascript","jsdoc","json","jsx","jsxfactori","jsxfactory를","jsx를","ko","korean:","lib","librari","lib가","listemittedfil","listfil","local","m","maproot","maxnodemodulejsdepth","modul","moduleresolut","msbuild","newlin","node.js/io.j","node_modul","noemit","noemithelp","noemitonerror","noerrortrunc","nofallthroughcasesinswitch","noimplicitani","noimplicitany,","noimplicitreturn","noimplicitthi","noimplicitthis,","noimplicitusestrict","nolib","noresolv","nostrictgenericcheck","nounusedloc","nounusedparamet","null","null과","number","object","out","outdir","outdir로","outfil","outfile과","outfile을","p","paths[2]","pl","polish:","portuguese(brazil):","preserveconstenum","preservesymlink","pretty[1]","project","pt","react.createel","reactnamespac","removecom","right","rootdir","rootdirs[2]","ru","russian:","scripthost","simplifi","skipdefaultlibcheck","skiplibcheck","skiplibcheck를","sourcemap","sourcemap에","sourcemap을","sourceroot","spanish:","spread","strict","strict\"","strict\"을","strictfunctiontyp","strictfunctiontypes이","strictnullcheck","strict를","string","string[]","stripinternal[1]","suppressexcesspropertyerror","suppressimplicitanyindexerror","symlinked된","symlinks를","t","target","tr","traceresolut","tradit","tsconfig.json","tsconfig.json를","tsconfig.json에서만","tslib로부터","turkish:","tw","type","typeroot","typescript","types를","undefin","us.","utf","v","version","void에","w","watch","webwork","zh","►","가능하다는","가능한","가능합니다.","가지","가진","각","값은","값이","같습니다:","같은","객체","객체를","건너뛰기[default","건너뜁니다.","검사","검사를","검사에","검색할","것입니다).","결정.","결정됩니다.","결합된","경로","경로로","경로에","경로일","경우","경우,","관련).","관련된","관련사항","구문","구조를","그","그리고","기능을","기본","기본값","기준으로","깊이.","끝의","나열합니다.","나타내는","내보내지","내보낼","내보냅니다.","내에서","내용은","다룹니다.","다른","다시","다음과","단일","단지","대상","대상으로","대상을","대신","대한","대해","데","데이터를","데코레이터","데코레이터에","도메인에","도움말을","동일한","되었습니다.","등..)","디렉토리","디렉토리.","디렉토리는","디렉토리로","디렉토리를","디렉토리의","디렉토리입니다.","디버거가","디버거를","디버깅","때","또는","또한","라이브러리","라이브러리는","라이브러리의","라인","라인에서는","런타임","런타임에","레이블에","로그","로드","루트","리다이렉트합니다.","리스트가","리스트에서","리액트","리터럴에","매개","매개변수를","매핑","맵","맵과","맵에","맵으로","메세지","메세지를","메시지를","메타","모듈","모듈로","모듈에서","모드로","모드에서는","모든","목록.","목록과","목록에","목록을","목록입니다.","목록입니다.가능한","문서를","문서을","문에","문자열","및","바이트","반복","반환값이","발생시킵니다.","방법","방출된","방출에는","방출을","방출하지","방출합니다.","버전","버전을","변경","변수에","변환합니다","별도의","보고된","보고하지","보고합니다.","보여줍니다.","부분에","불과합니다.","불리하여","비","비슷합니다).","비활성화합니다.","사용:","사용되는","사용되지","사용하도록","사용하세요.","사용하여","사용하지","사용할","사용합니다.","사용합니다.\"react\"","사용합니다.기본","사이즈","삽입됩니다.","상대적","색상","생성","생성된","생성하지","생성합니다.","선언","선언에","선언을","설계","설명","설정","설정하기","설정해야","소스","소스가","소스를","소스에","수","수도","순서","순서는","순서표(bom)를","스위치","스타일","스타일을","슬래시","시","시그니처","시그니처가","시그니처의","시작","시작하는","시점에","시퀀스","실제","실행합니다.","실험단계입니다.","실험적인","아닌","아래에서","않고","않는","않습니다.","않으며","않으면","암시한","억제합니다.","엄격한","없는","없을","연결의","연결하여","연결할","열거형","영향을","예:","예외사항은","오류","오류가","오류를","옵션","옵션은","옵션을","와치","와치하여","위치","위치가","위치는","위치를","위치에","위치할","위한","위해","위해서만","유효한","의존성","이","이름을","이름의","이슈를","이슈을","이하를","인덱스","인덱싱하는","인수는","일관성이","일부로","임포트","임포트와","임포트합니다.","입력","있고","있는","있습니다(한","있습니다.","있습니다.►","있습니다.자세한","있지","자세한","자체와","적용됩니다.","전달된","정보를","정의가","제거합니다.","제공합니다.","제네릭","제안","제어하기","제외한","제한을","주석을","주의사항:","주입되는","주지","줄이지","중","중지합니다.","지시자를","지역","지역화,","지우지","지원:","지원을","지정:","지정되지","지정된","지정하기","지정한","지정합니다.","진단","집합입니다","참조","참조는","참조하세요.","찾아야","처리됩니다)","초과","초기화하고","최대","최신","추가하지","출력","출력에","출력에서는","출력을","출력합니다.","커맨드","커스텀","컨텍스트를","컨텐츠가","컴파일","컴파일된","컴파일러","컴파일러를","컴파일러에","컴파일러의","컴파일에","컴파일의","컴파일하세요.이","컴파일합니다.","케이스에","코드","코드에","타입","타입에","타입에서","타입으로","타입의","트리플","파싱을","파일","파일(*.d.ts)의","파일(lib.d.ts)은","파일과","파일로","파일에","파일에서","파일을","파일의","파일이","파일처럼","팩토리","포함되어","포함된","포함될","포함됩니다.","포함하지","폴더","폴더의","표시하는","표현식과","표현식에","프로젝트를","프로젝트에서","프로젝트의","프로퍼티","플랫폼)","하고","하나입니다.","하는","할","할당","할당할","함께","함수","함수를","함수의","합니다.","해당하는","해석","해석의","해석하기","해석하지","허용되며","허용되지","허용하지","허용합니다","허용합니다.","헤더","헬퍼","헬퍼를","호출된","확인하세요.","활성화하면","활성화합니다."],"pages/Project References.html":["\"../converter\";","\"../src\"","\"../utils\",","\"compileroptions\":","\"endpoint\"","\"go","\"last\"","\"library\"","\"path\":","\"prepend\":","\"references\":","\"solution\"","#","(.d.ts)","(.j","(.js,","(e.g.","(may","(otherwis","(see","(tsc","(which","*",".d.t",".d.ts)",".d.ts,",".d.ts.map,",".j","/","//","/src/converter.t","/src/units.t","/test/convert","/test/unit","/tsconfig.json","3.0","3.0,","32);",">","[","\\","]","^","abov","act","actual","ad","add","additionally,","again,","allow","along","alway","amount","anoth","anyth","appear","appear:","array","array.","assert.areequal(converter.celsiustofahrenheit(0),","automat","await","awar","awkward","b","b:","bad","bar","bar/tsconfig.json","base","befor","behav","behind","below)","better","between","both","boundari","build","build.","builds.","built","c","can't","caus","caveat","central","certain","chang","check","checking,","clean:","cleaning.","clone","cloning.","code","combin","commandlin","common","compat","compil","compiler.","compiling,","components,","composit","config","configur","constraint","contain","continu","control","convert","copi","copy.","correct","correctly.","correspond","creat","current","d","date","declar","declarationmap","declarationmap,","default","definition\"","delet","depend","dependencies,","detect","determin","develop","directori","disk","do","doesn't","don't","done","doubl","dry)","dry:","e.g.","each","each:","edit","editor","editor,","editors.","effect","emit","empti","enabl","enabled.","end","endpoint","enforc","ensur","entri","error","error,","errors,","errors.","etc.),","even","exampl","example:","examples.","except","exist","explain","explicit","explicitli","fairli","faster","featur","few","file","file'","file,","file.","file:","files).","files,","files.","files:","find","first.","flag","flag)","flag,","flexibl","folder","folder,","folders.","following:","foo/prd.tsconfig.json","forc","force:","fulli","gener","general,","given","go","good","graph","greatli","group","guidanc","hand","happen:","have","help","here","i/o","imagin","implement","implicit","import","improv","includ","increment","incur","inform","inherit","instead","intend","intern","interoperable.","introduc","invok","it'","it.","itself","keep","kept","key","layer","layout","lead","leaf","learn","let'","level","librari","list","load","local","log","logic","long","longer","look","make","manag","map","maps.","match","matter","memori","mind","mitig","mode","modul","modules,","modules.","more","more.","msbuild","much","much.","multipl","name","name).","name,","navig","need","need.","new","node","noemitonerror","normal","normally,","note","noth","now","number","object","of.","off","on","on.","onc","oper","option","options.","orchestr","order","organ","out","outdir","outfil","outfile,","output","overal","overhead","p","p,","pair","parent","pass","path","pattern","pieces.","place","point","point;","possibl","practic","prepend","presenc","present","preserv","previously,","print","probabl","problem","problems,","process","process,","produc","program","program.","proj","project","project'","project,","project.","projects,","projects.","projects;","properti","property,","provid","pull","quickli","re","reason,","recommend","reduc","refer","referenc","reference,","reference:","reference?","references.","references;","rel","remot","renam","repo","requir","respect","result","results.","root","rootdir","run","same","scene","see","separ","set","set,","setting,","short)","show","simpl","simpli","singl","situat","skip","small","smaller","smart","solut","solv","sourc","specif","specifi","speed","spuriou","src","src/tsc/tsconfig.json","src/tsconfig.json","src/tsconfig.json,","src/tsconfig_base.json,","start","startup","structur","subdirectori","subfold","subproject","subsequ","support","switch.","syntax","system","team","test","test).","testing:","tests.t","there'","thing","things:","this,","those","though","time","times,","timestamp","tool","top","trade","transit","transpar","true","tsc","tsc,","tsc.","tsconfig","tsconfig.json","tsconfig.json.","turn","twice","two","type","typecheck","typescript","unexpect","units,","unless","unnecessari","until","up","us","usag","usual","verbos","verbose)","verbose:","veri","violated,","visibl","w","want","wasn't","watch","watch:","way","ways.","we'r","we'v","well","weren't","what'","wherein","whether","with.","without","work","workflow","workflows,","worri","wouldn't","you'd","you'll","{","}","},","레퍼런스","프로젝트"],"pages/Compiler Options in MSBuild.html":["(x86)\\msbuild\\microsoft\\visualstudio\\v$(visualstudioversion)\\typescript\\microsoft.typescript.target","(예:","(이","1.7","1.7).이렇게","allowj","allowsyntheticdefaultimport","allowunreachablecod","allowunusedlabel","alwaysstrict","amd,","baseurl","boolean","c:\\program","charset","classic","commonjs,","crlf","declar","declarationdir","diagnost","disablesizelimit","emitbom","emitdecoratormetadata","es3,","es5,","es6","experimentalasyncfunct","experimentaldecor","f5키를","fals","file","forceconsistentcasinginfilenam","help","importhelp","init","inlinesourc","inlinesourcemap","isolatedmodul","jsx","jsxfactori","lf","lib","listemittedfil","listfil","local","maproot","maxnodemodulejsdepth","modul","moduleresolut","msbuild","msbuild에서","msbuild에서의","newlin","node","noemit","noemithelp","noemitonerror","nofallthroughcasesinswitch","noimplicitani","noimplicitreturn","noimplicitthi","noimplicitusestrict","nolib","noresolv","nostrictgenericcheck","nounusedloc","nounusedparamet","out","outdir","outfil","path","preferreduilang","preserv","preserveconstenum","preservesymlink","pretti","react","reactnamespac","removecom","rootdir","skipdefaultlibcheck","skiplibcheck","sourcemap","sourceroot","strict","strictfunctiontyp","strictnullcheck","string","stripintern","studio","suppressexcesspropertyerror","suppressimplicitanyindexerror","system","target","toolsvers","traceresolut","true","true를","tsc","ts를","type","typeroot","typescriptadditionalflag","typescriptallowsyntheticdefaultimport","typescriptallowunreachablecod","typescriptallowunusedlabel","typescriptalwaysstrict","typescriptbaseurl","typescriptcharset","typescriptcompileblock","typescriptdeclarationdir","typescriptemitbom","typescriptemitdecoratormetadata","typescriptexperimentalasyncfunct","typescriptexperimentaldecor","typescriptforceconsistentcasinginfilenam","typescriptgeneratesdeclar","typescriptimporthelp","typescriptinlinesourc","typescriptinlinesourcemap","typescriptisolatedmodul","typescriptjsxemit","typescriptjsxfactori","typescriptlib","typescriptmaproot","typescriptmodulekind","typescriptmoduleresolut","typescriptnewlin","typescriptnoemithelp","typescriptnoemitonerror","typescriptnofallthroughcasesinswitch","typescriptnoimplicitani","typescriptnoimplicitreturn","typescriptnoimplicitthi","typescriptnoimplicitusestrict","typescriptnolib","typescriptnoresolv","typescriptnostrictgenericcheck","typescriptnounusedloc","typescriptnounusedparamet","typescriptoutdir","typescriptoutfil","typescriptpreserveconstenum","typescriptpreservesymlink","typescriptreactnamespac","typescriptremovecom","typescriptrootdir","typescriptskipdefaultlibcheck","typescriptskiplibcheck","typescriptsourcemap","typescriptsourceroot","typescriptstrict","typescriptstrictfunctiontyp","typescriptstrictnullcheck","typescriptstripintern","typescriptsuppressexcesspropertyerror","typescriptsuppressimplicitanyindexerror","typescripttarget","typescripttoolsversion이","umd,","visual","vs와","watch","xml","값","값은","개발을","개요","걸프,","경로","경우","구분된","그런트","그리고","기능은","내의","눌러도","다른","대한","데","도구를","동일한","등)","디버깅","또는","로드","만약","맵핑","맵핑이","메시지가","모든","목록","무엇일까요?","문자열","버전에서","버전을","버전의","빌드","빌드가","빌드를","빌드하는","빌드합니다.","사용자에게는","사용하는","사용하여","사용할","사이의","설정","설정하세요.","설치된","속성","속성을","수","쉼표로","시","식별합니다","신뢰할","않습니다","않습니다.","않으면","업그레이드하라는","여기에","여러분의","예제","예제에서는","옵션","옵션은","위한","이렇게","이름","있는","있습니다.","자동","자동으로","전용","제공되지만","제한된","지원되는","지원되지","지원이","지정되지","지정할","첫","최신","컴파일러","컴파일러에","컴퓨터에","태그와","파일","파일을","파일의","편집","표시됩니다","프로젝트","프로젝트가","프로젝트를","프로젝트에서","하면","허용된","허용합니다.","확인하세요.msbuild","환경을"],"pages/Integrating with Build Tools.html":["\"!node_modules/**/*.ts\"]","\"./src/index.tsx\",","\".js\"]","\".ts\",","\".tsx\",","\".web.js\",","\".webpack.js\",","\"bundle.js\"","\"output.js\"","\"output.js\")","\"t","'.ts'","'.ts'와","'.tsx'","'.tsx'를","'t","()","(err)","(err,","(맨",".add(\"main.ts\")",".bundle()",".entry(\"entry.ts\")",".pipe(process.stdout);",".pipe(ts({",".plugin(\"tsify\",",".run(funct",".use(typescript())","//","/\\.tsx?$/,","0.16beta",":","=",">","[","[\"\",","[\"**/*.ts\",","[\"ts\"]);","]","api","awesom","basic","browserifi","browserify()","build","bundle.j","default","dev","duo","duo(__dirname)","entry.t","entry:","err;","extensions:","fals","filename:","frankwallis/duo","fs","fs.writefilesync(out,","function","function(grunt)","g","grunt","grunt.initconfig({","grunt.loadnpmtasks(\"grunt","grunt.registertask(\"default\",","gruntfile.j","gulp","gulp.src(\"src/*.ts\")","gulp.task(\"default\",","gulpfile.j","instal","ivogabe/gulp","jspm","jspm@beta","jspm의","loader","loader\"","loader'에","loader:","loaders:","loader에","main.t","manag","microsoft.typescript.default.prop","microsoft.typescript.msbuild를","microsoft.typescript.target","module.export","module:","msbuild","nightli","noimplicitani","noimplicitany:","npm","nuget","nuget과","out","out:","output:","p","packag","path","path.join(__dirname,","require(\"browserify\");","require(\"duo","require(\"duo\");","require(\"fs\")","require(\"gulp","require(\"gulp\");","require(\"path\")","require(\"tsify\");","resolve:","results)","results.code);","return","save","smrq/tsifi","src:","test:","throw","true","true,","ts","ts\");","ts:","tsifi","tsresult","tsresult.js.pipe(gulp.dest(\"built/local\"));","typescript","typescript\");","typescriptsamples/jspm","typestrong/grunt","us","var","webpack","webpack.config.j","{","}","})","}));","});","},","};","가능한","가진","검색하세요","결과를","기본","내용:","내용은","다시","다이얼로그와","대안:","대한","도구들","도구와","또는","라인","로컬에","매니저","모든","빌드","사용","설정","설치","설치가","설치된","아래)","업데이트하여","여기를","옵션","완료되면","우","위)와","의해","인터페이스","입니다.","자세한","작성합니다.","정의에","주의사항:","지원은","참조하세요.","처리됩니다.","추가합니다.","출력","커맨드","컴파일된","컴파일러","클릭","통합","파일에","파일은","파일을","패키지","포함하도록","프로젝트","프로젝트의","하세요!","하세요:","해석","현재","확장자로","확장자를"],"pages/Nightly Builds.html":["\"/node_modules/typescript/lib\"","\"typescript.tsdk\":","\"typescript_tsdk\":","&","(mac)","(microsoft.typescript.targets,","(tsc.exe,",".",".vscode/settings.json","/node_modules/typescript/lib","/usr/local/lib/node_modules/typescript/lib","12","14","2013","2013:","2015","2015:",">","build에는","code","drop을","framework","g","id","idea","ide를","instal","intellij","languag","lib.d.ts,","master","microsoft.typescript.compiler:","microsoft.typescript.default.props,","microsoft.typescript.msbuild:","midnight까지","msbuild","msbuild에","nightli","nightlies는","node_modul","npm","npm과","npm을","nuget","nuget를","nuget에","packages:","powershel","prefer","pst","set","studio","sublim","text","text를","tsscript","two","typescript","typescript@next","typescript@next가","typescript를","typescript의","user","visual","vs","vscode","vsdevmode.ps1","www.myget.org에서","가능합니다.","가정합니다.","가져올","같은","같이","경우:","구성을","구성해야","기반으로","나머지","내용은","노력하고","다운로드.","다음과","다음을","대부분의","대상","대한","도구를","도구만","도구뿐만","등.)","또한","라인","로컬","문서를","및","배포됩니다.다음과","배포하기","버전:","버전의","변경","부분에서는","브랜치의","빌드","빌드는","빌드를","사용","사용에","사용하도록","사용하여","사항에는","새로운","서비스","선택합니다:","설정이","설치","설치되어","설치하거나","설치한","설치할","설치해야","섹션의","수","수도","스크립트","실행합니다:","아니라","않지만","언어","업데이트","업데이트하세요:","업데이트할","없습니다.","위와","위키","위한","위해","이","이미","이용","있다고","있습니다.","있습니다.먼저","있지","자세한","작업","전역으로","전체","주의사항:","참조하세요.","참조하십시오.","창에서","커맨드","커스텀","통해","파일","파일을","패키지를","페이지를","포함되어","폴더에","프로그램을","프로젝트","프로젝트를","플러그인","플러그인을","필요는","함께","합니다.","합니다.npm","현재"],"pages/release notes/TypeScript 3.8.html":["\"./some","\"./utilities.js\";","\"compileroptions\":","\"dynamicpriority\"","\"es2020\",","\"fallbackpolling\":","\"moduleresolution\":","\"node\",","\"privat","\"react\";","\"some","\"target\":","\"usefsevents\",","\"watchdirectory\":","\"watchfile\":","\"watchoptions\":","\"강한\"","\"빠르고","\"약한","\"최상위","\"해결","#","#foo","#foo;","#name:","#sidelength:","${this.#name}!`);","'#foo'","'#foo'는","'#name'은","'10'","'10'을","'20'","'c'.","'component'","'foo'","'foo'만","'noimplicitany'","'person'","'stuff'","'stuff'는","'this.#foo'","'this.foo'","(#)","(ecmascript","(es2020","(es6)","(export","(jsdoc","(nullish","(option","(preserv","(top","(type","(which","(디폴트):","(예를","(위를","*","*/","*또한*","...",".catch(",".j",".t","/**","//","100","100;","10;","14초에서","1초로","1초에","200;","2015","2020","20;","3","3.8","3.8는","3.8에서는","3.8은","4가지",":(","=","===","=>","@privat","@private은","@protected는","@protected입니다.","@public,","@public은","@readonli","@t","@type","`b`","`square`의","`undefined`를","access","allowj","any)","api,","api에","assumechangesonlyaffectdirectdepencies을","assumechangesonlyaffectdirectdependencies에서는","async","attempt","await","await\"이라는","await)","await로,","await은","await을","b","babel에서","bar,","baz","be","bearimy\");","bigint","bindings,","boom!","both.","button","buttonprop","c","c().#foo);","c().foo);","c()[\"#foo\"]);","c()[\"foo\"]);","chaining),","check","checkj","chelper()","ci를","class","coalescing),","code와","compon","console.error(e))","console.log(`hello,","console.log(a.equals(b));","console.log(greeting);","console.log(instance.chelper());","console.log(instance.dhelper());","console.log(new","console.log(this.stuff);","const","constructor()","constructor(foo:","constructor(name:","constructor(sidelength:","d","d();","default","dhelper()","dynamicprioritypolling:","ecmascript","ecmascript2020은","ecmascript3에서도!","ecmascript의","effects가","equals(other:","error!","error:","es2017","es2020","es2020용","es2020을","esnext","export","exports)","exports를","export를","export만","extend","fallbackpolling:","fetch(\"...\");","field","fields)","filea.t","filea.ts를","filea.ts와","filea.ts의","fileb.ts,","fileb.ts를","fileb.ts만","filec.t","filec.ts를","filed.ts를","fixedpollinginterval:","flow를","foo","foo().stuff++;","foo().stuff;","foo,","foo;","function","github으로","greet","greet()","here.","import","import(...)","imports,","imports/sid","importsnotusedasvalues.","imports를","import나","import를","import에서","import하지","instal","install을","instanc","interfac","isolatedmodules,","javascript","javascript(유사한","javascript는","javascript에","jeremi","jeremy.#nam","js","jsconfig.json에","jsdoc","jsdoc을","level","main()","modifiers)","modul","module\";","module)","module.js\";","module과","module의","module이","name","name;","names)","new","new:","node_modules안에서","node_modules에","node_modules의","non","npm","ns","nullish","number)","number;","only)","option","origin","other.#sidelength;","person","person(\"jeremi","preserve:","print","printstuff()","prioritypollinginterval:","privacy)","privacy)\"는","privacy)는","privat","private,","private프로퍼티","properti","protected와","public","public,","pull","refer","remove:","request,","request를","request에서","request을","respons","response.text();","return","sidelength:","sidelength;","someth","specifi","squar","square(100);","stage","string","string)","studio","synchronouswatchdirectory:","syntax)","syntaxerror","syntaxerror!","system인","target","target과","target을","this.#foo","this.#foo;","this.#nam","this.#sidelength","this.foo;","this.stuff","transpilemodul","tsconfig.fullbuild.json이나","tsconfig.json과","type","type,","typeerror","typeerror:","typescript","typescript가","typescript는","typescript를","typescript의","type과","type선언이","type은","type을","undefin","us","use?)","usefsev","usefseventsonparentdirectory:","util","valu","visual","watch","watchdirectory:","watchfile:","watchopt","watchoptions는","watchoptions란","weakmap은","weakmap을","within","writetostuff()","{","{number}","{};","{}와","}","},","};","~~~","~~~~","~~~~~","~~~~~~~~~","~~~~~~~~~~~~~~~","~~~~~~~~~~~~~~~~~~~~~~","가","가능을","가능한","가능합니다.","가려지기","가지","가지고","가지기","가진","가집니다:","각","각각","각각의","간격으로","간주됩니다.","감시","감시는","감시되는","감시를","감시와","감시하는데","감지하기","감지할","값들을","값을","값이","강제하기","강한","갖는","같은","같이","걱정하지","걱정할","검사","검사를","검사하면","검사합니다,","검사합니다.","검사해야","겁니다;","것도)과","것은","것을","것이","것이고,","것이며,","것입니다.","경우","경우,","경우가","경우에","경우에만","계속","고려","고정된","곳입니다.","과정","관련된","관련이","관한","괜찮을","구문","구문과","구문은","구문을","구문이","구성할","구현에","구현을","구현이","구현하고","규칙이","그렇지","그리고","그중","급격한","기꺼이","기능과","기능에","기능은","기능을","기능이","기다려서","기반입니다.","기본값으로","기본적인","기존","나은","나중까지","남아있는","내보내는","내부를","내에서","내에서만","내용은","네이밍","네이티브","높은","누수를","느려질","느리게","느슨한\"","는","다르다는","다르지","다른","다릅니다!","다운","다음과","다음으로","단일","달리,","당신의","대부분의","대상에서","대상으로","대상이","대한","대해","더","덜","덮어쓰기","데","도움이","도입하는","동일하게","동작을","동작이며,","동작하는지","동작하며","동작하며,","동작하지","동작합니다","동작합니다.","동적","동적인","되기","되며,","됩니다.","두면","두었다는","들어,","디렉터리","디렉터리는","디렉터리를","디렉터리에","디렉터리에게","디렉터리의","디자인","따라","따라서","때","때,","때는","때때로","때문에","때문에,","때문이고,","때문입니다.","때에만","또","또는","또한","라고","라이브러리","런타임","런타임에","런타임에도","런타임에서","런타임에서는","런타임에서도","런타임은","런타임을","레벨","레벨에서","레벨에서만","를","리눅스에서","리눅스와","리터럴이","마자막으로,","마지막","마찬가지로","마찬가지로,","만","만들고","만듭니다.","만약","많으며,","많은","맞지","매우","맨","먼저","메모리","멤버로","멤버를","명시적으로","명심해야","명확하지","몇","몇몇","몇몇은:","모두","모듈","모듈로","모듈의","모듈인지","모드에서는,","모든","모호해","무언가를","문맥에","문자로","문제가","바꾸는","밖에서","반대로)를","반면,","반면에,","받았습니다:","받은","발생시킵니다.","발생하는","발생하면","발생한다는","발생할","방법","방법\"","방법은","방법이","방지하기","버전은","버전을","번","번들러내에서의","번에","번째","범위를","범위에서","베이스를","베이스에서","베이스에서는,","변경","변경),","변경된","변경될","변경사항을","변경에","변경은","변경을","변경의","변경이","변동성이","변화가","변화를","변화에","별도로,","병합","보고","보고하며","보실","보이지","보일러","보장하는데","보장합니다.","보존될","보존하지만,","보존합니다.","부릅니다.","부족하거나/혹은","불가능합니다.","비공개","비공개(hard","비공개(soft","비공개가","비공개는","비공개를","비공개와","비공개이기","비활성화할","비활성화합니다.","빈번할","빌드)","빠른","빠를","사용","사용되는","사용되지","사용될","사용될수","사용은","사용자가","사용자는","사용자들에게","사용자들의","사용자로부터도","사용자에게는","사용자에겐","사용하기","사용하는데,","사용하면,","사용하여","사용할","사용할지","사용합니다.","사용해본","사용해야","사이드","사항에서","사항은","살펴봅시다:","삶의","상관없이","상당히","상위","상태에서","상황마다","상황에","새로운","생각할","생각해봐야","생략될","서브","서브클래싱을","서비스에","선언","선언되어야","선언되었다고","선언되지","선언된","선언만","선언에","선언에서는,","선언은","선언을","선언이","선언한","선택적","설정을","설정할","설치하고,","설치하기","설치하며,","설치합니다.","세션을","속도","속도가","수","수가","수는","수도","수에","수정된","수집하는데","쉽게","쉽습니다.","스니펫을","시","시간을","시스템","시스템의","시스템이","시작합니다.","시행되며,","식별자를","실수로","실패","실행되기를","실행하여","실험적","싶을","쓰여지기","쓰이는","아니기","아니라","아니면","아니지만,","아닙니다.","아래에","아무도","아주","안됩니다.","안에서","안정될","안정적인","않기","않는","않도록","않습니다.","않아도","않으면","않은","않을","않지만","알려줄","알릴","알아","암시적이며","압도하여,","약","어디서든","어떤","언급했듯이,","언어들과","엄격하게","업데이트가","업데이트하기","없기","없는","없도록","없습니다!","없습니다.","없을","에디터","여러","여전히","연기된","연기하겠다면","영향을","예를","예상되는","오류!","오류로","오류를","오류이지만","오직","옵션","옵션들","옵션으로","옵션은","옵션을","옵션이","옵션이나","와","완벽하게","완전히","왓쳐(파일","왓쳐가","왓쳐를","왓쳐와는","왓쳐의","왜냐하면","외부에서","요구했습니다.","우리는","운영체제/파일","운영체제에서","위에","위한","위해","위해,","위해서","유사합니다.","유용합니다","유용합니다.","유의할","유의해야","유일하기","유일하다는","유일합니다.","유저로서","유지됩니다.","으로","은","의도","의도하는","의미입니다.","의미합니다.","의존성","의해","이","이것은","이것을","이것이","이기","이는","이동하여","이라고","이러한","이런","이로","이를","이름(privat","이름은","이름을","이름이","이미","이벤트","이벤트를","이상","이상이고,","이에","이용해","이전","이전에","이전의","이전인","이팩트","인스턴스가","인스턴스는","인스턴스마다","인식합니다.","인해","일들이","일반","일반적이어서","일반적인","일반적입니다.","일부","일수","일시적으로","읽기","읽어보세요.","잃으키지","있고","있고,","있는","있다는","있다면,","있도록","있습니다.","있습니다:","있으며","있을","있지만,","있지만;","자세한","자주","작동하거나","작동할","작성자일","작성하여","작업","작업을","잘","장점은","재","재검사/재빌드","재검사/재빌드하지않고,","재귀적인","재빌드","적게","적기","적이","전략.","전략에서","전략을","전에","전용","전용(read","전적으로","전체","점은","점이","접근","접근을","접근이","접근하거나","접근하면","접근할","정말로","정보는","정보는,","정의한","정확할","제거되므로,","제거됩니다.","제거하거나","제거하는","제공하며,","제공합니다.","제안의","제어하기","제한을","제한적으로","조금","종류의","종종","좋은","주로,","주석을","주의해야","줄여주었습니다.","줄의","줍니다.","중요한","즉시","증분","지워집니다","지원은","지원을","지원하고","지원하기","지원하지","지원할","지원합니다.","지정자","지정자는","지정자로","지정자를","지정자입니다:","지정합니다.","직접","진입점을","진짜","질문을","질의","짓밟지","차이점은","참고하세요","참조하세요.)","참조합니다.","찾을","처럼)","처리합니다.","첫","체이닝","초기에는","초기화","초래서는","최근에","최상위","최적화","추가되었습니다.","추가하여","추가합니다:","추가했습니다.","추적할","추천하는","출력","출력물에서","출력할","출력합니다.","출력했을","충돌에","캄파일","컴파일","컴파일러","컴파일러/언어","코드","코드가","큐를","큰","클래스","클래스내에서","클래스는","클래스도","클래스를","클래스안의","클래스에","클래스에서","클래스와","클래스의","키워드를","타임/디자인","타임에","타임에만","타입","타입으로","타입으로만","타입의","타입이","타입인가?","탐지할","태그들은","태그를","통한","통해","트리가","특정","파생된","파일","파일/디렉터리","파일과","파일들은","파일로","파일만","파일보다","파일뿐만","파일에는","파일에서","파일은","파일을","파일의","파일이","패턴을","편리한","포함되어","포함하고","포함하는","포함한","폴더에","폴리필될","폴링","표기와","프로젝트","프로젝트는","프로퍼티","프로퍼티가","프로퍼티는","프로퍼티들(privat","프로퍼티를","프로퍼티에","프로퍼티에서,","프로퍼티와","프로퍼티이기","프로퍼티처럼","플래그는","플래그를","플레이트를","피하기","필드","필드는","필드는,","필드로","필드를","필드에","필드에서는,","필드의","필요가","필요합니다.","하고,","하기","하나요","하나요?\"","하나의","하는","하는지에","하단","하며","하에서","하위","하위클래스에서","하지","하지만","하지만,","한","한다는","할","할까요?","할당되기","할당할","함께)에서","함께,","함수","함수를","합니다.","항상","해당","해시/우물","향상이며,","허용되었기","허용합니다.","허용했지만,","현재","현재,","호출합니다.","혹은","확대하는","확인","확인하세요.","확인할","확장","환경과","환경에서","활성화되면,","활성화해야","활용합니다.","효율적으로","후","훌륭한","휴리스틱을","흐름에서는","흥미로울"]},"length":44},"tokenStore":{"root":{"0":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"}":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"b":{"1":{"0":{"1":{"0":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"o":{"7":{"4":{"4":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"docs":{}},"docs":{}},"docs":{}},"x":{"docs":{},"f":{"0":{"0":{"docs":{},"d":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"docs":{}},"docs":{}}},"대":{"docs":{},"신":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"부":{"docs":{},"터":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0029118136439267887},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},".":{"1":{"6":{"docs":{},"b":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}},"docs":{}},"5":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"docs":{}},"]":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"으":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"개":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"1":{"0":{"0":{"0":{"docs":{},"}":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},")":{"docs":{},";":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}},"1":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"}":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}}}},"1":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.004159733777038269},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}},"]":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"진":{"docs":{},"수":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"라":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"a":{"docs":{},"m":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}},"}":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"자":{"docs":{},"가":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"1":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}},"2":{"3":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"3":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617}}}},"}":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"4":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"초":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"6":{"docs":{},"진":{"docs":{},"수":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"7":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.006344171292624901},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}}},".":{"1":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},".":{"2":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"docs":{}}},"3":{"6":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"docs":{}},"7":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},")":{"docs":{},".":{"docs":{},"이":{"docs":{},"렇":{"docs":{},"게":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}},"8":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}},".":{"4":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"docs":{}}},"docs":{}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}}}}}}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"부":{"docs":{},"터":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"x":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"씩":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"이":{"docs":{},"어":{"docs":{},"야":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"개":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"초":{"docs":{},"로":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"에":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}}}},"2":{"0":{"0":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"1":{"3":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},":":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"4":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"5":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.010869565217391304},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"서":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"부":{"docs":{},"터":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},",":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},":":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"7":{"docs":{},"과":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"이":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"docs":{}},"2":{"0":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"docs":{}},"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},",":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588}}}},"2":{"6":{"1":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"docs":{}},"docs":{}},"6":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"8":{"0":{"8":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"docs":{}},"2":{"4":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"docs":{}},"docs":{}},"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"]":{"docs":{},";":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}}}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"와":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}},"라":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"인":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"진":{"docs":{},"수":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}}},".":{"0":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}}},"2":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"3":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"부":{"docs":{},"터":{"docs":{},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"7":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"8":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}},"에":{"docs":{},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}},"docs":{}},"}":{"docs":{},")":{"docs":{},"}":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},";":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"단":{"docs":{},"계":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"개":{"docs":{},"의":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}},"3":{"2":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},"안":{"docs":{},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"4":{"docs":{},"m":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"7":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"]":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}},"r":{"docs":{},"d":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},".":{"0":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"7":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"8":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":5.00046511627907}},"에":{"docs":{},"서":{"docs":{},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"은":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.004186046511627907}}}},"docs":{}},"}":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},")":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"개":{"docs":{},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"으":{"docs":{},"로":{"docs":{},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"4":{"0":{"0":{"0":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"docs":{}},"docs":{}},"5":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},")":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837}}},"}":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"가":{"docs":{},"지":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"5":{"0":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}},"docs":{}},"2":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}}}},"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0023858214042263124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}},"분":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":2.5}}},"]":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"라":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},".":{"0":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}},"docs":{}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},";":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"m":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"x":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"6":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"로":{"docs":{},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"]":{"docs":{},";":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"7":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}},"8":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"진":{"docs":{},"수":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}},"9":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"]":{"docs":{},"+":{"docs":{},"$":{"docs":{},"/":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}}}}}}},"docs":{},"c":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00823045267489712},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0021413276231263384},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.01545253863134658},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0037209302325581397}},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"m":{"docs":{},"d":{"docs":{},"를":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0021929824561403508},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"x":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}},"c":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"s":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0029118136439267887},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00823045267489712},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.003067484662576687},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0040858018386108275},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029171528588098016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.00946372239747634},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0027906976744186047}},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"(":{"docs":{},"p":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},"h":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002631578947368421}}}},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498}}}}}}}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"u":{"docs":{},"m":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0033034450212364322}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"x":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},";":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135}}}}}}}}}}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"s":{"docs":{},")":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546}}}}}}}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}},"(":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"(":{"docs":{},"`":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"$":{"docs":{},"{":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"}":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"\"":{"docs":{},"$":{"docs":{},"{":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}},"s":{"docs":{},"}":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}},"'":{"docs":{},"$":{"docs":{},"{":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}},"w":{"docs":{},"a":{"docs":{},"l":{"docs":{},"k":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"s":{"docs":{},"a":{"docs":{},"y":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},".":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"[":{"0":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"docs":{}}}}}}}}}}}}}},"1":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"docs":{}}}}}}}}}}}}}},"5":{"docs":{},"]":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}},"docs":{}},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}}}}}}}}}},"\"":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"i":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"o":{"docs":{},"h":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"b":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}},"g":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}}},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"s":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}},"i":{"docs":{},"!":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"a":{"docs":{},"l":{"docs":{},"f":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}}}}}},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{},"e":{"docs":{},".":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"x":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}}}},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079}}}}}}},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}}}}}}}}}}}}}}},"'":{"docs":{},"w":{"docs":{},"o":{"docs":{},"o":{"docs":{},"f":{"docs":{},"!":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"!":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"!":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}},"2":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}},"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}}}}}},"i":{"docs":{},"d":{"1":{"docs":{},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"{":{"docs":{},"x":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"2":{"docs":{},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"{":{"docs":{},"x":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}}}},"a":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0035285815102328866}}}}}}}}}}}}},".":{"docs":{},"x":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"b":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154}}}}}}}}}}}}}}}}}},"(":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}}}}}}}},")":{"docs":{},";":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203}}}},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}}}}}}}}},"d":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"[":{"docs":{},"s":{"docs":{},"y":{"docs":{},"m":{"docs":{},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"e":{"docs":{},"w":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}}}}},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},")":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}},"y":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},"p":{"docs":{},"t":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":10}}}}}}},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.006128702757916241}},"u":{"docs":{},"r":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}},"e":{"docs":{},"(":{"docs":{},"i":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}}}}}}}}}}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}}}},"s":{"docs":{},"/":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}}}}}},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}}},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}}}},"d":{"docs":{},"e":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}},"나":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"\"":{"docs":{},"]":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}}},"와":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}}},"?":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"e":{"docs":{},"를":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}},"o":{"docs":{},"n":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.004206098843322818}}}}}}}},"u":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}},"a":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"j":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"s":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},")":{"docs":{},"에":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}},"의":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},",":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0033112582781456954}}},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":5.00503524672709},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"l":{"docs":{},"y":{"docs":{},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}},"p":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}},"y":{"docs":{},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0069767441860465115},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323}}}}}}},"r":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323}}}},"[":{"2":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"docs":{}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}},"?":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.00530035335689046}}}},"나":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}},"대":{"docs":{},"신":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}},"u":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807}}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"e":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105}},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}}}}},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.005701754385964913},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.013213780084945729},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.004940014114326041},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0016638935108153079},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0054533060668029995},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.008171603677221655},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.006745362563237774},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.007698887938408896},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.003500583430571762},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.006516587677725118},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.017241379310344827},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0032119914346895075},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.00530035335689046},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.00772626931567329},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0065116279069767444}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}},"나":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"i":{"docs":{},"c":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"]":{"docs":{},"이":{"docs":{},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Templates.html":{"ref":"pages/declaration files/Templates.html","tf":0.07692307692307693}},"s":{"docs":{},"를":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}},"를":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"o":{"docs":{},"u":{"docs":{},"d":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"n":{"docs":{},"e":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},".":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"p":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.006843455945252352}}}}}}}}}},"r":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"c":{"docs":{},"k":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002631578947368421}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0043859649122807015}},"e":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"u":{"docs":{},"r":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"e":{"docs":{},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}},"#":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"이":{"docs":{},"나":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"c":{"docs":{},"h":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},")":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}},"s":{"docs":{},"k":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0022185246810870773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499}}}},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}}},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625}}},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}},"l":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}}},"e":{"docs":{},"e":{"docs":{},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}}}},"s":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"r":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"d":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0062752129090094125}}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}}}},"s":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895}}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895}}},"와":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"o":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}},"u":{"docs":{},"s":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}},"v":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}}}},"d":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736}},"n":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.003500583430571762}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"\"":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"j":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"s":{"docs":{},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}}},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},")":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}},"n":{"docs":{},"g":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.005107252298263534}}}}},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881}}}}}}}},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}}}}}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"\\":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"e":{"docs":{},"(":{"4":{"2":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"docs":{}},"docs":{},"\"":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}},"o":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}}}}}},"{":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"c":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}}}}}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}}}}}}}}}}}},"{":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}}}}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"안":{"docs":{},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"e":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"l":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},".":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"z":{"docs":{},"o":{"docs":{},"o":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00855431993156544}}}}}}}}}},"\"":{"docs":{},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"\"":{"docs":{},")":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"와":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}}}}}}}},"l":{"docs":{},"f":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"(":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"1":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"docs":{},")":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},".":{"docs":{},"#":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},")":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},")":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"[":{"docs":{},"\"":{"docs":{},"#":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},")":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"]":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"y":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"e":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}},"a":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"b":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"d":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},";":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}}}},"x":{"docs":{},";":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0021929824561403508}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}},"[":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"c":{"docs":{},"+":{"docs":{},"+":{"docs":{},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}},";":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0033112582781456954}}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}},"와":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"n":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"s":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"z":{"docs":{},"e":{"docs":{},"c":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}}}}}},"h":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}},"을":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}}}}}},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},":":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"v":{"docs":{},"e":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"m":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"l":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"e":{"docs":{},"s":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"이":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}}}}}}},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},".":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}},"]":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}}}},"'":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},".":{"docs":{},".":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"이":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}},")":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}},")":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}}}}}}}}}}}}}},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"g":{"docs":{},"o":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"f":{"docs":{},"w":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},"/":{"docs":{},"?":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},"i":{"docs":{},"d":{"docs":{},"=":{"5":{"1":{"8":{"0":{"0":{"7":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"/":{"docs":{},"t":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"/":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"에":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"k":{"docs":{},"a":{"docs":{},".":{"docs":{},"m":{"docs":{},"s":{"docs":{},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.009592326139088728},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004084014002333722},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"x":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}},"s":{"docs":{},")":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}},"p":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"x":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}},"r":{"docs":{},"e":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"r":{"docs":{},"s":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"i":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"와":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"?":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}},"c":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"s":{"docs":{},")":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}}}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"j":{"docs":{},"s":{"docs":{},"x":{"docs":{},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"t":{"0":{"0":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"1":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"2":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"3":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"4":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"5":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.007360672975814932}}},"1":{"0":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}},"1":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}},"2":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"3":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"4":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"5":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"6":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"7":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"8":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.007360672975814932}}},"2":{"0":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}},"1":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}},"2":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"3":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"4":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.005257623554153523}}},"3":{"0":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"1":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"2":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"3":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"4":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"5":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"4":{"0":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"1":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"2":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"3":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135}}},"5":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"6":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"7":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"8":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.011291460832745237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00517655758920318},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0030701754385964912},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.021630615640599003},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.03785488958990536},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0088339222614841},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0425531914893617},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":2.516051364365971},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.00906344410876133},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.007069913589945012},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.007323943661971831},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.013189448441247002},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.008431703204047217},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0033349213911386373},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0017844396859386152},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.014705882352941176},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.010666666666666666},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.01694915254237288},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005673758865248227},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.010214504596527068},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0243161094224924},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.013824884792626729},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":5.0088372093023255}},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}}},"가":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.006420545746388443},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0031007751937984496},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002689376961004034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029171528588098016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0027906976744186047}}},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.003943661971830986},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.008}}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008025682182985553},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004796163069544364},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"와":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.004815409309791332},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0021413276231263384},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0027906976744186047}}},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}}}},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"!":{"docs":{},"\"":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},",":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588}}}}},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"처":{"docs":{},"럼":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"도":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"보":{"docs":{},"다":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"’":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"만":{"docs":{},"의":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"나":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"b":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"x":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}},"o":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"m":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}},"s":{"docs":{},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"j":{"docs":{},"s":{"docs":{},"p":{"docs":{},"m":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"s":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"이":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}},"@":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"가":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}}}},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.004067295248659641},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}}},"을":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"/":{"docs":{},"g":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}},"\"":{"docs":{},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"o":{"docs":{},"f":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0016638935108153079},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.002044989775051125},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}},"e":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"은":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"(":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"n":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"s":{"docs":{},"를":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}}}}}}},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"과":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"선":{"docs":{},"언":{"docs":{},"이":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},"\"":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"\"":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}}}},"o":{"docs":{},"o":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},"y":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"{":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231}}},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}},"x":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"y":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"i":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922}}}}}},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"#":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}}}}}}}}},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"e":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}},"i":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"p":{"0":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}},"1":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}},"docs":{}},"x":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"y":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0037753657385559227}},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"[":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"]":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"z":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}},"t":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}}}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}},"i":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}},"까":{"docs":{},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.011494252873563218}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}},"e":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"s":{"docs":{},".":{"docs":{},"b":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}}}}}}}},"l":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"1":{"6":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}}}},"docs":{}},"docs":{}}}}}}}}}}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0031376064545047063}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}},"와":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"타":{"docs":{},"입":{"docs":{},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"에":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}},"e":{"docs":{},")":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135}},"e":{"docs":{},";":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"를":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}}}},"n":{"docs":{},"g":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},":":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"?":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},"s":{"docs":{},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0037753657385559227}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"!":{"docs":{},"\"":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"\"":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"'":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"m":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"s":{"2":{"3":{"0":{"7":{"docs":{},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}},"docs":{}},"4":{"5":{"docs":{},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004796163069544364},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.015197568389057751}},"c":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.021450459652706845},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.005107252298263534}},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":10.012765957446808},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.008171603677221655}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"서":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}},"만":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"이":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"라":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}}}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"\"":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"\"":{"docs":{},"컴":{"docs":{},"파":{"docs":{},"일":{"docs":{},"러":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}}}}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"파":{"docs":{},"일":{"docs":{},"을":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},"과":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"n":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"이":{"docs":{},"나":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}}}}}}}}}}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"와":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.006284367635506678},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00911854103343465}}},"y":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},".":{"docs":{},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004084014002333722}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"로":{"docs":{},"부":{"docs":{},"터":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"를":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},":":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}},"x":{"docs":{},"i":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002962085308056872}}},"과":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"을":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Templates.html":{"ref":"pages/declaration files/Templates.html","tf":10}},"e":{"1":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"o":{"docs":{},"r":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"o":{"docs":{},"r":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"s":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.006128702757916241}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"s":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},".":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}}}}},"(":{"docs":{},"c":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}},"x":{"docs":{},"t":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"b":{"docs":{},"o":{"docs":{},"x":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}},"를":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"c":{"docs":{},"h":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}},"a":{"docs":{},"m":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"u":{"docs":{},"e":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005673758865248227},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00911854103343465}},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.00906344410876133},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0054988216810683424},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.011347517730496455},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"}":{"docs":{},")":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}},"]":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.011494252873563218}}},"로":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}}}},"i":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887}},"e":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"과":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}}}},"e":{"docs":{},"e":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"'":{"docs":{},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"으":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"i":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"e":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"c":{"docs":{},"k":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"m":{"docs":{},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"3":{"4":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"docs":{}},"docs":{}}}}}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"m":{"docs":{},"i":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"p":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"i":{"docs":{},"c":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}}},"n":{"docs":{},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"d":{"docs":{},"o":{"1":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"2":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.004206098843322818}},",":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},".":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"l":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.004206098843322818}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"n":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"5":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}},"docs":{}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0024958402662229617}}}}}},"r":{"docs":{},"k":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"m":{"docs":{},"e":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"?":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}}}}}}}}},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.012618296529968454},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"?":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}}}}}}},")":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.009174311926605505},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},">":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135}}}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821}},"u":{"docs":{},",":{"docs":{},"v":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0035285815102328866},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0016638935108153079},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"[":{"docs":{},"]":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},")":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"k":{"docs":{},"]":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},"[":{"docs":{},"]":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"]":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}},"p":{"docs":{},"]":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}},"가":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821}}},"라":{"docs":{},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546}}},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.005257623554153523}}}},"와":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.007360672975814932}}},"w":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"o":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}},"?":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}}},"]":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"?":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}}}},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"이":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"인":{"docs":{},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"능":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"하":{"docs":{},"며":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}},"게":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"지":{"docs":{},"만":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"다":{"docs":{},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"므":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"거":{"docs":{},"나":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"도":{"docs":{},"록":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"고":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"성":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"을":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.007067137809187279},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"함":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"해":{"docs":{},"야":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}},"케":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"/":{"docs":{},"생":{"docs":{},"성":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"을":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}},"지":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.003585835948005379},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0027906976744186047}},"가":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.004507042253521127},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0038580246913580245},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0022185246810870773},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"므":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"게":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"면":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"며":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"이":{"docs":{},"드":{"docs":{},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.011029411764705883},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}},",":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}}},"져":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"오":{"docs":{},"려":{"docs":{},"면":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"도":{"docs":{},"록":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"(":{"docs":{},"일":{"docs":{},"반":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}},"에":{"docs":{},"서":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"만":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"고":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"면":{"docs":{},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"지":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},"만":{"docs":{},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}},"는":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}},"데":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}},"올":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"왔":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}},"옵":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"야":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},"만":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"와":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"야":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"온":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356}},"다":{"docs":{},"는":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"정":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"즉":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"해":{"docs":{},"봅":{"docs":{},"시":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"장":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0033802816901408453},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"진":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0017844396859386152},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"다":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"질":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"수":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"만":{"docs":{},"한":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"집":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"끔":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"드":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014790164540580515}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"라":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}},"와":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"깝":{"docs":{},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"르":{"docs":{},"치":{"docs":{},"며":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"킵":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}},"리":{"docs":{},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"킵":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"키":{"docs":{},"는":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"도":{"docs":{},"록":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}},"졌":{"docs":{},"는":{"docs":{},"지":{"docs":{},"만":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"로":{"docs":{},"채":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"독":{"docs":{},"성":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"짜":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"짐":{"docs":{},"을":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"까":{"docs":{},"운":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"상":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"시":{"docs":{},"성":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"려":{"docs":{},"져":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"지":{"docs":{},"기":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"감":{"docs":{},"사":{"docs":{},"하":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}}}}}}}},"싸":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"는":{"docs":{},"데":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"지":{"docs":{},"며":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"주":{"docs":{},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}},"줄":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"춰":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"지":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"하":{"docs":{},"는":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},"고":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"기":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"할":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"쌀":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"쌉":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}}},"시":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"되":{"docs":{},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"와":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"하":{"docs":{},"는":{"docs":{},"데":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"규":{"docs":{},"칙":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"과":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}},"들":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"이":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"엔":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"에":{"docs":{},"서":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"모":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}},"가":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}},"그":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0033802816901408453},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0031007751937984496},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0021929824561403508},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"래":{"docs":{},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0028585040495474035}}}},"러":{"docs":{},"나":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"면":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}},"한":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"므":{"docs":{},"로":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"냥":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"런":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}},"데":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"트":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"리":{"docs":{},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0016638935108153079},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"레":{"docs":{},"이":{"docs":{},"션":{"docs":{},"에":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"렇":{"docs":{},"지":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"듯":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"다":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}},"들":{"docs":{},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"은":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"대":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"룹":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"화":{"docs":{},"하":{"docs":{},"는":{"docs":{},"데":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887}}},"의":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"것":{"docs":{},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"럼":{"docs":{},"에":{"docs":{},"도":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"동":{"docs":{},"안":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"만":{"docs":{},"두":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"중":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"누":{"docs":{},"구":{"docs":{},"나":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}}},"르":{"docs":{},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}}}},"릴":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"락":{"docs":{},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"됨":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"군":{"docs":{},"가":{"docs":{},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"수":{"docs":{},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"다":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}},"양":{"docs":{},"한":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}},"하":{"docs":{},"기":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"시":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"운":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"로":{"docs":{},"드":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}},"할":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},".":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}},"음":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.012084592145015106},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.010071090047393365},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}},"과":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.007049345417925478},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.004713275726630008},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.006193425440686041},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.009040333796940195},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}},"을":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}},"처":{"docs":{},"럼":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"른":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.006201550387596899},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.005407653910149751},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0043859649122807015},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0037753657385559227},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.004234297812279464},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.006344171292624901},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0038580246913580245},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.003512664078387872},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0034083162917518746},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.005107252298263534},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0033349213911386373},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.005988023952095809},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0024982155603140615},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.013245033112582781},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005673758865248227},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.005581395348837209}}},"루":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}}},"도":{"docs":{},"록":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"게":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"르":{"docs":{},"게":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}},"지":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"만":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}},"다":{"docs":{},"'":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"며":{"docs":{},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"기":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"소":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"룰":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"룹":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"릅":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"!":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"행":{"docs":{},"히":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"도":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"수":{"docs":{},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"중":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}},"뤘":{"docs":{},"던":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"형":{"docs":{},"성":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}},"뤄":{"docs":{},"지":{"docs":{},"도":{"docs":{},"록":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"보":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}},"이":{"docs":{},"얼":{"docs":{},"로":{"docs":{},"그":{"docs":{},"와":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}},"등":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"록":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}},"할":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"장":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}},"과":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}},"은":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"으":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},")":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"가":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},".":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"의":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},".":{"docs":{},".":{"docs":{},")":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},")":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}}}},"문":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.010869565217391304},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}},"서":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.014134275618374558}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.004180602006688963},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}},"화":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}},"는":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"도":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}},"을":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"자":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}},"열":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0031007751937984496},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0030701754385964912},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.007137192704203013},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0027731558513588465},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.012345679012345678},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0024982155603140615},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00823045267489712},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}},"들":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"라":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}},"어":{"docs":{},"야":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"의":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}},"처":{"docs":{},"럼":{"docs":{},",":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"를":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"와":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}}},"제":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"없":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}},"들":{"docs":{},"이":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"점":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"법":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"서":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"맥":{"docs":{},"상":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.008948545861297539}}},"에":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"서":{"docs":{},"도":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}},"적":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135}},"으":{"docs":{},"로":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"으":{"docs":{},"로":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}},"및":{"docs":{"./":{"ref":"./","tf":0.0425531914893617},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003927729772191673},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.014492753623188406},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00851063829787234},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.005852842809364548},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}},"밖":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"도":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}},"방":{"docs":{},"법":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"은":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0030701754385964912},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.022058823529411766},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.008}}},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"며":{"docs":{},",":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887}}}}},"으":{"docs":{},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}},"도":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},",":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}},"대":{"docs":{},"로":{"docs":{},"라":{"docs":{},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"\"":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"식":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"을":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}},"들":{"docs":{},"과":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"이":{"docs":{},"며":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"은":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"과":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"출":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"되":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"된":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"에":{"docs":{},"는":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"을":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"하":{"docs":{},"지":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"지":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"하":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"면":{"docs":{},"서":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"기":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"\"":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"금":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"생":{"docs":{},"되":{"docs":{},"어":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"해":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}},"향":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"\"":{"docs":{},"에":{"docs":{},"서":{"docs":{},"도":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}}},"정":{"docs":{},"식":{"docs":{},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"문":{"docs":{},"할":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"해":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}},"번":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"역":{"docs":{"./":{"ref":"./","tf":0.0425531914893617}},",":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}},"가":{"docs":{},"이":{"docs":{},"드":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}}}},"하":{"docs":{},"는":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"째":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"에":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}},"들":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"링":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},"이":{"docs":{},"나":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"과":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"된":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"하":{"docs":{},"거":{"docs":{},"나":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"러":{"docs":{},"(":{"docs":{},"예":{"docs":{},".":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},"내":{"docs":{},"에":{"docs":{},"서":{"docs":{},"의":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"호":{"docs":{},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837}}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"형":{"docs":{},"도":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"만":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}},"상":{"docs":{},"황":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}},"은":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}},"에":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}}},"마":{"docs":{},"다":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"자":{"docs":{},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}},"태":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"\"":{"docs":{},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"에":{"docs":{},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"대":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"적":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.012863268222963315},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"으":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356}}}},"이":{"docs":{},"냐":{"docs":{},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"라":{"docs":{},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"면":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"면":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}},"거":{"docs":{},"나":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"인":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"임":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"급":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"위":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}}}}}}}}},"의":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}},"속":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"계":{"docs":{},"층":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"받":{"docs":{},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"을":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"하":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"여":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"된":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"해":{"docs":{},"서":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}},"되":{"docs":{},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"할":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"호":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"작":{"docs":{},"용":{"docs":{},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"관":{"docs":{},"없":{"docs":{},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},"다":{"docs":{},"는":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}},"수":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.013481363996827915}},"들":{"docs":{},"의":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.003965107057890563}}},"이":{"docs":{},"거":{"docs":{},"나":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}},"응":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"기":{"docs":{},"해":{"docs":{},"봅":{"docs":{},"시":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}},"단":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"만":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}},"상":{"docs":{},"할":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"세":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"당":{"docs":{},"히":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"소":{"docs":{},"개":{"docs":{"./":{"ref":"./","tf":10},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":10},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"되":{"docs":{},"었":{"docs":{},"고":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"된":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}}}}}}}}}}}},"스":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.005995203836930456},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.004764173415912339},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.005016722408026756}},"맵":{"docs":{},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"의":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"수":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"에":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"의":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"위":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"프":{"docs":{},"트":{"docs":{},"웨":{"docs":{},"어":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"문":{"docs":{},"자":{"docs":{},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"비":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},"수":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.019261637239165328},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.012568735271013355},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.025915492957746478},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.014388489208633094},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.02558139534883721},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.014559068219633943},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.014912280701754385},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.017461066540821142},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.012102196324518153},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.02117148906139732},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.013481363996827915},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.013422818791946308},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.010030864197530864},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.014790164540580514},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00823045267489712},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.015678254942058625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.009193054136874362},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.013490725126475547},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.010481181515007145},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.01454234388366125},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.011085180863477246},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.018957345971563982},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.008620689655172414},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.008264462809917356},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.016059957173447537},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.006309148264984227},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.02086230876216968},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0176678445229682},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.02207505518763797},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.022598870056497175},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.009929078014184398},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.01627906976744186}},"준":{"docs":{},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625}}},"에":{"docs":{},"서":{"docs":{},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},"도":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0050704225352112674},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.003875968992248062},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0032119914346895075},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},"정":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0034770514603616135}},"합":{"docs":{},"시":{"docs":{},"다":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"하":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"려":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"면":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"지":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"여":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"는":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588}}}},"될":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"해":{"docs":{},"야":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}},"봅":{"docs":{},"시":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"된":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}},"없":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"행":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"했":{"docs":{},"다":{"docs":{},"고":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"하":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"면":{"docs":{},",":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}},"된":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}},"한":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"다":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"동":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"고":{"docs":{},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}},"와":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"월":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"학":{"docs":{},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"단":{"docs":{},"이":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"가":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"에":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"집":{"docs":{},"하":{"docs":{},"는":{"docs":{},"데":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"언":{"docs":{},"제":{"docs":{},"나":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"든":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"지":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}},"급":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"했":{"docs":{},"던":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"듯":{"docs":{},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"하":{"docs":{},"지":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"어":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"들":{"docs":{},"처":{"docs":{},"럼":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"과":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"에":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}},"서":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"처":{"docs":{},"럼":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"와":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},"래":{"docs":{},"핑":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"(":{"docs":{},"u":{"docs":{},"n":{"docs":{},"w":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}},"오":{"docs":{},"타":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}}},"류":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.003875968992248062},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00258827879460159},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004667444574095682},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.006309148264984227},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705}},"가":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.004815409309791332},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.007525083612040134},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002689376961004034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"!":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002631578947368421},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"!":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942}}}}}},"도":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},")":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"들":{"docs":{},"을":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},"이":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"른":{"docs":{},"쪽":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"으":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"에":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}},"늘":{"docs":{},"날":{"docs":{},"에":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"버":{"docs":{},"로":{"docs":{},"드":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0031376064545047063},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.008321775312066574}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}}},"만":{"docs":{},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"가":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.005547850208044383}}},"하":{"docs":{},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"된":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}},"와":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}}}},"라":{"docs":{},"이":{"docs":{},"드":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"하":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"해":{"docs":{},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}},"딩":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"직":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},"게":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"던":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"래":{"docs":{},"된":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"염":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}},"프":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"브":{"docs":{},"젝":{"docs":{},"트":{"docs":{},"라":{"docs":{},"면":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"요":{"docs":{},"청":{"docs":{},"은":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}},"하":{"docs":{},"면":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"한":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"구":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"사":{"docs":{},"항":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"소":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.013418903150525088}},"들":{"docs":{},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.003500583430571762}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"나":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"와":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.003500583430571762}}},"(":{"docs":{},"예":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"점":{"docs":{},"은":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"약":{"docs":{},"하":{"docs":{},"자":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"되":{"docs":{},"어":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"즘":{"docs":{},"에":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841}},"견":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}},"도":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"된":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"했":{"docs":{},"다":{"docs":{},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"를":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"였":{"docs":{},"을":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"하":{"docs":{},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"존":{"docs":{},"성":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0034770514603616135},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}}}},"은":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"이":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0034770514603616135},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333}},"나":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"들":{"docs":{},"은":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"을":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}},"하":{"docs":{},"지":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}},"적":{"docs":{},"인":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"이":{"docs":{},"라":{"docs":{},"면":{"docs":{},":":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}},"미":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"w":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"와":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"또":{"docs":{},"한":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"기":{"docs":{},"도":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0033112582781456954}}},"한":{"docs":{},"다":{"docs":{},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"인":{"docs":{},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"도":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"가":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"와":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"할":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"해":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"서":{"docs":{},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"한":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"이":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.004815409309791332},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.005995203836930456},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.006201550387596899},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.004991680532445923},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.007017543859649123},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.008494572911750826},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00582698341550874},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.004940014114326041},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0055511498810467885},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.008948545861297539},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.004629629629629629},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.002958032908116103},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0034083162917518746},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.006128702757916241},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.008431703204047217},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.008099094807050978},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.006417736289381563},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004739336492890996},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.01818181818181818},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0017844396859386152},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.007360672975814932},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.025735294117647058},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.006258692628650904},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.007067137809187279},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.005547850208044383},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.005518763796909493},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.018666666666666668},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005673758865248227},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0074418604651162795}},"곳":{"docs":{},"을":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"슈":{"docs":{},"에":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"을":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"동":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"할":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"하":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"이":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}},"기":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"세":{"docs":{},"요":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"여":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"름":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.002044989775051125},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0033349213911386373},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.003500583430571762},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.009917355371900827},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0033112582781456954},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"인":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0033112582781456954},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"어":{"docs":{},"야":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"지":{"docs":{},"만":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"은":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"들":{"docs":{},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"이":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}},"(":{"docs":{},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"용":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"한":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"할":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"하":{"docs":{},"여":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"면":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}}}},"했":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"해":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"전":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"과":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"인":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"제":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.007069913589945012},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"것":{"docs":{},"뿐":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"다":{"docs":{},"음":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"들":{"docs":{},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"라":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"러":{"docs":{},"한":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0037437603993344427},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0037209302325581397}}},"미":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"상":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},"는":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}},"인":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"해":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"에":{"docs":{},"서":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}},"과":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"이":{"docs":{},"고":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"득":{"docs":{},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"때":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"런":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"렇":{"docs":{},"게":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"도":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"유":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"가":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"를":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.006934812760055479}}}},"점":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"해":{"docs":{},"함":{"docs":{},"으":{"docs":{},"로":{"docs":{},"써":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"하":{"docs":{},"기":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"면":{"docs":{},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"여":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"해":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"야":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"한":{"docs":{},"다":{"docs":{},"면":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"할":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}}},"건":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.005823627287853577},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004084014002333722},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.005581395348837209}}},"후":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}},"에":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"는":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}},"부":{"docs":{},"터":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},",":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}},"엔":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"더":{"docs":{},"라":{"docs":{},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"들":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"이":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"을":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}},"번":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"엔":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"에":{"docs":{},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"외":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"도":{"docs":{},",":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}},"나":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}},"야":{"docs":{},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"해":{"docs":{},"보":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}}}}}}},"거":{"docs":{},"나":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"기":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"면":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"종":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"중":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"터":{"docs":{},"러":{"docs":{},"블":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.010869565217391304}},"로":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}},"레":{"docs":{},"이":{"docs":{},"터":{"docs":{},"와":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":5}}}}}}},"니":{"docs":{},"셜":{"docs":{},"라":{"docs":{},"이":{"docs":{},"저":{"docs":{},"를":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"로":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"란":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"론":{"docs":{},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"어":{"docs":{},"지":{"docs":{},"며":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"하":{"docs":{},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"벤":{"docs":{},"트":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}}}}},"팩":{"docs":{},"트":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"있":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}},".":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.016051364365971106},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.006284367635506678},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.011990407673860911},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.014728682170542635},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.011403508771929825},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.012741859367626238},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.010309278350515464},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.008723235527359239},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.008948545861297539},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.004629629629629629},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00776483638380477},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.012345679012345678},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.011588275391956374},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.006128702757916241},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.011804384485666104},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.011434016198189614},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.006843455945252352},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.007001166861143524},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.012440758293838863},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.008922198429693077},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.011029411764705883},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.009040333796940195},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.014134275618374558},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.009933774834437087},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.008},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.01694915254237288},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.013824884792626729},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.008372093023255815}},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}},"먼":{"docs":{},"저":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"브":{"docs":{},"라":{"docs":{},"우":{"docs":{},"저":{"docs":{},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"제":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"러":{"docs":{},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}},"런":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"페":{"docs":{},"이":{"docs":{},"지":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}},"v":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"가":{"docs":{},"능":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"그":{"docs":{},"런":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"렇":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"러":{"docs":{},"나":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"다":{"docs":{},"소":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"또":{"docs":{},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"아":{"docs":{},"마":{"docs":{},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"여":{"docs":{},"기":{"docs":{},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"예":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"전":{"docs":{},"형":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"(":{"docs":{},"해":{"docs":{},"당":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"기":{"docs":{},"본":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"►":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"자":{"docs":{},"세":{"docs":{},"한":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.004815409309791332},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.003875968992248062},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0029118136439267887},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0021929824561403508},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0053533190578158455},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.005563282336578581},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.00530035335689046},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.005518763796909493},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}}},")":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"!":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"(":{"docs":{},"한":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"게":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},"끔":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.003875968992248062},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.006351446718419196},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0016638935108153079},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0023858214042263124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0023820867079561697},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0035545023696682463},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0021413276231263384},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.01276595744680851},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}},"지":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"를":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}},"데":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}}},"도":{"docs":{},"록":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"뿐":{"docs":{},"만":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"음":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"다":{"docs":{},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"으":{"docs":{},"며":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"므":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"나":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"만":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}}},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}},"어":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"도":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"기":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"거":{"docs":{},"나":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"겠":{"docs":{},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"듯":{"docs":{},"이":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"었":{"docs":{},"다":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"던":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},"더":{"docs":{},"라":{"docs":{},"도":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}},"던":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"잘":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.012345679012345678},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"못":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"된":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}}},"됨":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.009708737864077669}}}},"한":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"해":{"docs":{},"냅":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}}}},"주":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"목":{"docs":{},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{},"이":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}},"해":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"할":{"docs":{},"만":{"docs":{},"한":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"어":{"docs":{},"야":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"지":{"docs":{},"면":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},"는":{"docs":{},"지":{"docs":{},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"진":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"의":{"docs":{},"해":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"사":{"docs":{},"항":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}}}}},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"제":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},"로":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"와":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"요":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},",":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},"변":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002962085308056872}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"석":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}},"을":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"으":{"docs":{},"로":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"은":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"의":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}},"입":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}},"되":{"docs":{},"는":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"진":{"docs":{},"행":{"docs":{"./":{"ref":"./","tf":0.0425531914893617}},"할":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"되":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"면":{"docs":{},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"어":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"하":{"docs":{},"면":{"docs":{},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"단":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"할":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"입":{"docs":{},"점":{"docs":{},"을":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"짜":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"참":{"docs":{},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.008293838862559242}},"해":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"여":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},")":{"docs":{},"또":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"사":{"docs":{},"항":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},":":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}},"여":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}},"하":{"docs":{},"기":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}},"는":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}}}},"조":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006611570247933884},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},")":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"를":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"데":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.00919732441471572},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.013824884792626729}},")":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}}}}},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"기":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},")":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"해":{"docs":{},"야":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"서":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"에":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"서":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"될":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"이":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"된":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},"(":{"docs":{},"원":{"docs":{},"래":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"되":{"docs":{},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}}}},"/":{"docs":{},"거":{"docs":{},"짓":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"/":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}}},"통":{"docs":{},"해":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"합":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":3.333333333333333}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"거":{"docs":{},"기":{"docs":{},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"하":{"docs":{},"기":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}}},"과":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}},"하":{"docs":{},"길":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"는":{"docs":{},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"의":{"docs":{},"례":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}},"되":{"docs":{},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"고":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"했":{"docs":{},"는":{"docs":{},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}}}}},"한":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"프":{"docs":{},"로":{"docs":{},"젝":{"docs":{},"트":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004796163069544364},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0023820867079561697},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Project References.html":{"ref":"pages/Project References.html","tf":5},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0075},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}}}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"가":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"그":{"docs":{},"래":{"docs":{},"머":{"docs":{},"가":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"들":{"docs":{},"에":{"docs":{},"겐":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"밍":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"에":{"docs":{},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"램":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"이":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"토":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"타":{"docs":{},"입":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"을":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}},"퍼":{"docs":{},"티":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.005701754385964913},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0031429099648733593},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.012345679012345678},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.013033175355450236},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.005710206995003569},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0027906976744186047}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0035087719298245615},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0016638935108153079},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.014492753623188406},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.007067137809187279},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0027906976744186047}}},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002631578947368421},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0021929824561403508},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}},"들":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"을":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}},"만":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"이":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"만":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"서":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"와":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},"부":{"docs":{},"터":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"중":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"인":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"이":{"docs":{},"기":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}},"처":{"docs":{},"럼":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"세":{"docs":{},"스":{"docs":{},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}},"록":{"docs":{},"시":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"레":{"docs":{},"임":{"docs":{},"워":{"docs":{},"크":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}},"피":{"docs":{},"드":{"docs":{},"백":{"docs":{},"은":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}}}},"하":{"docs":{},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"연":{"docs":{},"산":{"docs":{},"자":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0023858214042263124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0032558139534883722}},"글":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}},"다":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"고":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"번":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"정":{"docs":{},"되":{"docs":{},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}},"쪽":{"docs":{},"에":{"docs":{},"만":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"서":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"으":{"docs":{},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"곳":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"해":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"주":{"docs":{},"시":{"docs":{},"면":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}}},"지":{"docs":{},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"는":{"docs":{},"데":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"며":{"docs":{},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"어":{"docs":{},"야":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"당":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0038580246913580245},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004667444574095682},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0028551034975017845},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"되":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"한":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"하":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}},"준":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}},"야":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588}}},"결":{"docs":{},"책":{"docs":{},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"되":{"docs":{},"며":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"할":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"하":{"docs":{},"기":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"제":{"docs":{},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"줍":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},":":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}},"도":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"봅":{"docs":{},"시":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"서":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"석":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":5.008575512148642},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.005016722408026756},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"하":{"docs":{},"기":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"려":{"docs":{},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356}}}},"여":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"지":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"되":{"docs":{},"거":{"docs":{},"나":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"기":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"된":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"다":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"될":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"할":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0023820867079561697}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}}}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"을":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"의":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"시":{"docs":{},"/":{"docs":{},"우":{"docs":{},"물":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"확":{"docs":{},"인":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"할":{"docs":{"./":{"ref":"./","tf":0.02127659574468085},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"m":{"docs":{},"s":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"기":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}},"데":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"거":{"docs":{},"나":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"여":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"함":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"해":{"docs":{},"야":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"장":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"자":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"만":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"해":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"야":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},")":{"docs":{},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}},"하":{"docs":{},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"면":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"여":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"고":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"한":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"다":{"docs":{},"는":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},"시":{"docs":{},"켜":{"docs":{},"야":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"을":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"보":{"docs":{},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"실":{"docs":{},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"한":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"하":{"docs":{},"게":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"신":{"docs":{},"한":{"docs":{},"다":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"대":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"환":{"docs":{},"영":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.02127659574468085}}}}}}}},"경":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"과":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"서":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"는":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"만":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"\"":{"0":{"0":{"1":{"docs":{},"+":{"0":{"1":{"0":{"docs":{},"=":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{},".":{"1":{"9":{"docs":{},".":{"2":{"4":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}},"docs":{}},"docs":{}}},"docs":{},".":{"2":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"docs":{}}},"docs":{}},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}},"1":{"0":{"0":{"docs":{},"\"":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"1":{"docs":{},"\"":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}}}}},"docs":{}},"2":{"3":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"docs":{}},"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702}},"\"":{"docs":{},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333}}}}},"docs":{}}},"docs":{}},"\"":{"docs":{},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"+":{"2":{"docs":{},"*":{"3":{"3":{"docs":{},"/":{"1":{"1":{"docs":{},"=":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}}},"2":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}},"docs":{}}},"2":{"docs":{},".":{"0":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}}}},"docs":{}}},"docs":{}},"\"":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"3":{"docs":{},".":{"9":{"docs":{},".":{"0":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}}}}},"docs":{}}},"docs":{}},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"4":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"5":{"docs":{},".":{"0":{"docs":{},".":{"0":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"docs":{}}},"docs":{}},"\"":{"docs":{},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"6":{"docs":{},"\"":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"7":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"8":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"9":{"8":{"0":{"5":{"2":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.02086677367576244},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.002831524303916942},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.014791573285522188},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008025682182985553},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0037753657385559227},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0034770514603616135}}},"\"":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"!":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}},"y":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}}}}}},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},"w":{"docs":{},"d":{"docs":{},"y":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}}}}}},"u":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}}},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215}},"\"":{"docs":{},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}}},"s":{"docs":{},"x":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}},"o":{"docs":{},"n":{"docs":{},"!":{"docs":{},"*":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"p":{"docs":{},"h":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}},"m":{"docs":{},".":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"p":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"i":{"docs":{},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"k":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}}},"a":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"같":{"docs":{},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"b":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"처":{"docs":{},"럼":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}},"n":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"z":{"docs":{},"i":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}}}}},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}}}}}},"h":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"i":{"docs":{},"n":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"r":{"docs":{},"\"":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}},")":{"docs":{},";":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}}}}}}}}}},"p":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},"r":{"docs":{},"l":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}},"f":{"8":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"docs":{}}},"m":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},".":{"docs":{},"/":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"i":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"p":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"]":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}}},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"`":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}},"i":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"/":{"docs":{},"b":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}},"\"":{"docs":{},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}}},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"*":{"docs":{},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},"\"":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"x":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}},"\"":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}}}},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"s":{"docs":{},"/":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625}}}}}}}}}}}}}},"x":{"docs":{},"y":{"docs":{},"z":{"docs":{},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{},"!":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0034083162917518746}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"처":{"docs":{},"럼":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"x":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"]":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}},"\\":{"docs":{},"n":{"docs":{},"\\":{"docs":{},"n":{"docs":{},"\"":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},";":{"docs":{},",":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"j":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"/":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"/":{"docs":{},"j":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{},"/":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"/":{"docs":{},"t":{"docs":{},"s":{"docs":{},"c":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"\"":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}}},"\"":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"^":{"0":{"docs":{},".":{"6":{"docs":{},".":{"4":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"docs":{}}},"docs":{}}},"docs":{}},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"2":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"/":{"docs":{},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"l":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}}},"}":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}}}},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333}}}}}}}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"d":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617}}}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895}}}}}}}},"\"":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},")":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}}}},"d":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"와":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.009929078014184398},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"u":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}},"n":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617}}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}}}}}}},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}},";":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"i":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},"y":{"docs":{},"a":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}},"r":{"docs":{},"l":{"docs":{},"f":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"를":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}}}}}}}},"v":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"가":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"를":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"]":{"docs":{},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"w":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"g":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203}}}}},"e":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{},"\"":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}}}},"i":{"docs":{},"a":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},"]":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}}}}}}},"g":{"docs":{},"n":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"\"":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}}}}},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}},"s":{"2":{"0":{"1":{"5":{"docs":{},"\"":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"사":{"docs":{},"용":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},".":{"docs":{},"d":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"s":{"docs":{},"가":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}}},"6":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"7":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"docs":{}},"2":{"0":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"docs":{}},"docs":{}},"docs":{}},"3":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}}},"5":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"6":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"/":{"docs":{},"\"":{"docs":{},"e":{"docs":{},"s":{"2":{"0":{"1":{"5":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"와":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"가":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"►":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"는":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"x":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005673758865248227}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"에":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"]":{"docs":{},",":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}}}}}}}}},"a":{"docs":{},"s":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0016638935108153079}}}},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"n":{"docs":{},"d":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005673758865248227}},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"목":{"docs":{},"록":{"docs":{},"에":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},"과":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"d":{"docs":{},"\"":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"4":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},"docs":{}}}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"p":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}},"\"":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"s":{"docs":{},"\"":{"docs":{},"`":{"docs":{},"와":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}}},"와":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"라":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"/":{"docs":{},"*":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}},"u":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"g":{"docs":{},"a":{"docs":{},"c":{"docs":{},"y":{"docs":{},"/":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"\"":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333}}}}}}}},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"f":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"n":{"docs":{},"o":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"\"":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"\"":{"docs":{},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"j":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"/":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"/":{"docs":{},"j":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"n":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},":":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333}}}}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"\"":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}},"w":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231}}}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}}}}}}}}},"d":{"docs":{},"\"":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105}}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736}},"\"":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}}},";":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"나":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}}},"와":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"\"":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}}}}}}}}}}}}}}}},"x":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{},"\"":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"o":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}},";":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"만":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{},"\"":{"docs":{},"이":{"docs":{},"여":{"docs":{},"야":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"#":{"docs":{},"{":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"}":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}},"z":{"docs":{},"h":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"*":{"docs":{},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895}}}}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"}":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}}}}},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0031376064545047063}}}}}}},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}}}}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}}}}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203}}}}}},"c":{"docs":{},"t":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}}}},"m":{"docs":{},"u":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}},"t":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},":":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"d":{"docs":{},"k":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}},"_":{"docs":{},"t":{"docs":{},"s":{"docs":{},"d":{"docs":{},"k":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}}}}},"\"":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"라":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},":":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"와":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}}},"h":{"docs":{},"i":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}},"s":{"docs":{},"\"":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"s":{"docs":{},"c":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005673758865248227}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"을":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},"'":{"docs":{},"l":{"docs":{},"l":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"d":{"docs":{},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"m":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}},"h":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}}}}}}}}}}}}},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},":":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}},"s":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{},"b":{"docs":{},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"\"":{"docs":{},"}":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"\"":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"]":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}},"i":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"z":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"s":{"docs":{},"e":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}},"o":{"docs":{},"b":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}},"\"":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}},"d":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}}}}}}},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"y":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}},"h":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"\"":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}}}},"날":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"\"":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"$":{"docs":{},"$":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}}}}},"k":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}},"y":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}}}},"성":{"docs":{},"공":{"docs":{},"\"":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"존":{"docs":{},"재":{"docs":{},"\"":{"docs":{},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}},"환":{"docs":{},"경":{"docs":{},"\"":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"구":{"docs":{},"조":{"docs":{},"적":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"대":{"docs":{},"상":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"덕":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"사":{"docs":{},"전":{"docs":{},"\"":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"인":{"docs":{},"덱":{"docs":{},"스":{"docs":{},"로":{"docs":{},"\"":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"피":{"docs":{},"하":{"docs":{},"는":{"docs":{},"\"":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588}}}},"숨":{"docs":{},"겨":{"docs":{},"진":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"제":{"docs":{},"너":{"docs":{},"릭":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"직":{"docs":{},"렬":{"docs":{},"화":{"docs":{},"\"":{"docs":{},"를":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}},"다":{"docs":{},"른":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}},"문":{"docs":{},"맥":{"docs":{},"상":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}},"최":{"docs":{},"적":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"상":{"docs":{},"위":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"\"":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147}}}},"건":{"docs":{},"전":{"docs":{},"\"":{"docs":{},"하":{"docs":{},"지":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}},"아":{"docs":{},"마":{"docs":{},"도":{"docs":{},"\"":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"호":{"docs":{},"환":{"docs":{},"\"":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"리":{"docs":{},"터":{"docs":{},"럴":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"싱":{"docs":{},"글":{"docs":{},"톤":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00823045267489712}}}}}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333}}}}}}}}}}},"*":{"docs":{},"!":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}}}}}},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}}},"+":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"/":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"\"":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"=":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"발":{"docs":{},"견":{"docs":{},"\"":{"docs":{},"할":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"@":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"\"":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"s":{"docs":{},"/":{"docs":{},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"\"":{"docs":{},":":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}}}}}}}}},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}},"很":{"docs":{},"高":{"docs":{},"兴":{"docs":{},"认":{"docs":{},"识":{"docs":{},"你":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}},"您":{"docs":{},"好":{"docs":{},"吗":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"가":{"docs":{},"상":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}},"디":{"docs":{},"렉":{"docs":{},"터":{"docs":{},"리":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}},"배":{"docs":{},"포":{"docs":{},"\"":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"추":{"docs":{},"가":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"프":{"docs":{},"로":{"docs":{},"젝":{"docs":{},"트":{"docs":{},"\"":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"선":{"docs":{},"언":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"브":{"docs":{},"라":{"docs":{},"우":{"docs":{},"저":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}},"이":{"docs":{},"름":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"더":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"전":{"docs":{},"달":{"docs":{},"하":{"docs":{},"는":{"docs":{},"\"":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}},"!":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"*":{"docs":{},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}}}}}}}}},"강":{"docs":{},"한":{"docs":{},"\"":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"빠":{"docs":{},"르":{"docs":{},"고":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}},"약":{"docs":{},"한":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"해":{"docs":{},"결":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"'":{"0":{"docs":{},"'":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"1":{"0":{"0":{"docs":{},"'":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"docs":{},"'":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"을":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"1":{"docs":{},"'":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"docs":{},"'":{"docs":{},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"2":{"0":{"docs":{},"'":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}}},"docs":{},"'":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"3":{"docs":{},"'":{"docs":{},"이":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"5":{"docs":{},"'":{"docs":{},"가":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"[":{"docs":{},"]":{"docs":{},"'":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}},"'":{"docs":{},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"이":{"docs":{},"어":{"docs":{},"야":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"'":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{},"'":{"docs":{},"일":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"2":{"docs":{},"/":{"docs":{},"b":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"2":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"docs":{}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}},"r":{"docs":{},"x":{"docs":{},"j":{"docs":{},"s":{"docs":{},"/":{"docs":{},"b":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"r":{"docs":{},"x":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{},"]":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"j":{"docs":{},"s":{"docs":{},"/":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"/":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},".":{"docs":{},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"x":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"'":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}}}}}}}}}}}}}},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}},"j":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"s":{"docs":{},"'":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"'":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"'":{"docs":{},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"e":{"docs":{},"w":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"'":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"'":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"'":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}}}}}}}},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"'":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"'":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546}}}}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"[":{"docs":{},"]":{"docs":{},"'":{"docs":{},"타":{"docs":{},"입":{"docs":{},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"'":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"'":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"'":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}}}},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"/":{"docs":{},"*":{"docs":{},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"'":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}},"m":{"docs":{},"e":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"'":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"'":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"'":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"'":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},".":{"docs":{},"c":{"docs":{},"i":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"'":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"'":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"m":{"docs":{},"'":{"docs":{},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"x":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"/":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"1":{"docs":{},"'":{"docs":{},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"docs":{},"'":{"docs":{},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}}},"c":{"docs":{},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}},"'":{"docs":{},"작":{"docs":{},"업":{"docs":{},"도":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"이":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"r":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}},"o":{"docs":{},"r":{"docs":{},"'":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"'":{"docs":{},"?":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"u":{"docs":{},"r":{"docs":{},"'":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"'":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},";":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}},"'":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"a":{"docs":{},"m":{"docs":{},"r":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{},"를":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"'":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"'":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},"b":{"docs":{},"u":{"docs":{},"g":{"docs":{},"'":{"docs":{},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}},"'":{"docs":{},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"'":{"docs":{},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"안":{"docs":{},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"'":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"와":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"x":{"docs":{},"'":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}},"/":{"docs":{},"#":{"docs":{},"{":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"}":{"docs":{},"/":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"'":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"1":{"docs":{},"'":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"docs":{}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"2":{"docs":{},"'":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"docs":{}}}}},"z":{"docs":{},"h":{"docs":{},"/":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"'":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"'":{"docs":{},";":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}}}}}}}},"a":{"docs":{},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"'":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"'":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"과":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}},"y":{"docs":{},"'":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}},"r":{"docs":{},"g":{"docs":{},"s":{"docs":{},"'":{"docs":{},"를":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}},"b":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"'":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"!":{"docs":{},"'":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"'":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},".":{"docs":{},"과":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"만":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"2":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"docs":{}}}}}}},"2":{"docs":{},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"3":{"docs":{},"'":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"docs":{}}}}}}},"docs":{}}}}}},"l":{"docs":{},"y":{"docs":{},"'":{"docs":{},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"'":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},".":{"docs":{},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}},"d":{"docs":{},"'":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"'":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"'":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"'":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},"'":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}}},"'":{"docs":{},";":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"'":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}}}}}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"'":{"docs":{},"이":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"/":{"docs":{},"*":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"'":{"docs":{},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"'":{"docs":{},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"1":{"docs":{},"'":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"2":{"docs":{},"'":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"docs":{}}}}}},"w":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"'":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}}},"k":{"docs":{},"'":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"r":{"docs":{},"g":{"docs":{},"a":{"docs":{},"n":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}},"t":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"'":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}},"y":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},"h":{"docs":{},"i":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},"s":{"docs":{},"'":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},".":{"docs":{},"#":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"'":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"'":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"'":{"docs":{},"안":{"docs":{},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"r":{"docs":{},"t":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"'":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"'":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"과":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}},"b":{"docs":{},"'":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"가":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"'":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}},"e":{"1":{"docs":{},"'":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"2":{"docs":{},"'":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"docs":{},"'":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{},"e":{"docs":{},"'":{"docs":{},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"'":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}},"s":{"5":{"docs":{},"'":{"docs":{},"보":{"docs":{},"다":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498}}}}}},"docs":{}}},"u":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"'":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"이":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}},"x":{"docs":{},"'":{"docs":{},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"때":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"(":{"docs":{},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"'":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"'":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}},"#":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"'":{"docs":{},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"f":{"docs":{},"f":{"0":{"0":{"docs":{},"f":{"docs":{},"f":{"docs":{},"'":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}},"docs":{}},"docs":{}},"o":{"docs":{},"o":{"docs":{},"'":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"화":{"docs":{},"살":{"docs":{},"표":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"m":{"docs":{},"'":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{},"'":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"'":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821}},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"'":{"docs":{},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"b":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"'":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"'":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}},"버":{"docs":{},"리":{"docs":{},"는":{"docs":{},"'":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"!":{"docs":{},"=":{"docs":{},"=":{"docs":{},"'":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"\"":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"u":{"docs":{},"n":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"\"":{"docs":{},"'":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}},"$":{"docs":{},"{":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"}":{"docs":{},"'":{"docs":{},".":{"docs":{},"`":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"}":{"docs":{},"'":{"docs":{},"`":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}},"y":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"'":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"]":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"와":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"'":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}},"상":{"docs":{},"위":{"docs":{},"'":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"내":{"docs":{},"부":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"*":{"docs":{},"'":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}}},"네":{"docs":{},"임":{"docs":{},"스":{"docs":{},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}},"선":{"docs":{},"언":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"{":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"?":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"?":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"'":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}},"'":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"@":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"'":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"s":{"docs":{},"'":{"docs":{},"과":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}},"(":{"0":{"docs":{},".":{"0":{"2":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"5":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"docs":{}},"1":{"3":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"docs":{}},"docs":{}}},"1":{"7":{"docs":{},")":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"docs":{},")":{"docs":{},"과":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"2":{"docs":{},")":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"3":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"4":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"7":{"docs":{},")":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"9":{"docs":{},")":{"docs":{},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"b":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"t":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}}}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}}}}}},"i":{"docs":{},"c":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}},")":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"i":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"c":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"i":{"docs":{},"c":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}},"o":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"a":{"docs":{},"r":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"j":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"s":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}},"s":{"docs":{},"t":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"o":{"docs":{},"r":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"가":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"u":{"docs":{},"m":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"u":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}},"d":{"docs":{},"e":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}},"t":{"docs":{},"r":{"docs":{},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}}},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}}}}}}}},"i":{"docs":{},"n":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"o":{"docs":{},"f":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}},")":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}},"g":{"docs":{},"r":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},".":{"docs":{},"j":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"를":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}},"s":{"docs":{},"f":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},")":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}}}}}}},"f":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},".":{"docs":{},"e":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.004172461752433936}}}}}}}}}},"n":{"docs":{},"o":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}},"s":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"t":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"u":{"docs":{},"m":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"e":{"docs":{},"r":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"e":{"docs":{},"w":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"e":{"docs":{},"d":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}}}}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}},"e":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"c":{"docs":{},"t":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}}},"s":{"docs":{},"t":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942}}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"d":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}}}}}}},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"u":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.007067137809187279}}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"o":{"docs":{},"f":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}},")":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203}},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}}}},"b":{"docs":{},"l":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}},"o":{"docs":{},"o":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"p":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}}},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"c":{"docs":{},"e":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"e":{"docs":{},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}}}}}},"h":{"docs":{},"e":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}},"i":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}},"s":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}}}}}}}}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"n":{"docs":{},"g":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"s":{"docs":{},"c":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.006284367635506678},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.005547850208044383},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}},".":{"docs":{},".":{"docs":{},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"j":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"s":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"a":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"d":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}},"d":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.006042296072507553},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},"i":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"j":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"i":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}}}}}}}},"n":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}}}}}}}}}}}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0035285815102328866}}}},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}}},"g":{"docs":{},"e":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"s":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}}}}}},"d":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"b":{"docs":{},"u":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}},"e":{"docs":{},"p":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}}}}}}}},"o":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"y":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}}}},"w":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}}}}}}}}}},"i":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},")":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}}}}}}},"e":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"n":{"docs":{},"g":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}}}}},"u":{"docs":{},"b":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},".":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}}}}}}},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"n":{"docs":{},"i":{"docs":{},"x":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"o":{"docs":{},"n":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}},"s":{"docs":{},"e":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"r":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},")":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"m":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"나":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"l":{"docs":{},"l":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}}}},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}},"h":{"docs":{},"i":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"c":{"docs":{},"h":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"d":{"docs":{},"_":{"1":{"docs":{},"_":{"1":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"docs":{}}},"docs":{}},"u":{"docs":{},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"a":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}},"r":{"docs":{},"e":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"a":{"docs":{},"p":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"y":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}}},"c":{"docs":{},")":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}}}}},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176}}}},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}},"e":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},"a":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"s":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"h":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968}},"e":{"docs":{},")":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.015772870662460567}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"s":{"docs":{},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{},"e":{"docs":{},".":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}}}}}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196}}},".":{"docs":{},"g":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"s":{"2":{"0":{"1":{"5":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"docs":{}},"2":{"0":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"docs":{}},"docs":{}},"docs":{}},"6":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"docs":{}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},",":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"i":{"docs":{},"c":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}}}}},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}},"l":{"docs":{},"o":{"docs":{},"b":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.007067137809187279}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}},"[":{"4":{"2":{"docs":{},"]":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"docs":{}},"docs":{},"'":{"4":{"2":{"docs":{},"'":{"docs":{},"]":{"docs":{},")":{"docs":{},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"docs":{}},"docs":{}}}}}}}},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"s":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"4":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"docs":{}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"s":{"docs":{},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}},"r":{"docs":{},"g":{"docs":{},"a":{"docs":{},"n":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}},"x":{"8":{"6":{"docs":{},")":{"docs":{},"\\":{"docs":{},"m":{"docs":{},"s":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"\\":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},"\\":{"docs":{},"v":{"docs":{},"i":{"docs":{},"s":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{},"i":{"docs":{},"o":{"docs":{},"\\":{"docs":{},"v":{"docs":{},"$":{"docs":{},"(":{"docs":{},"v":{"docs":{},"i":{"docs":{},"s":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{},"i":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},"\\":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"\\":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"?":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"와":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}}},"또":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}}},"e":{"docs":{},"t":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.021739130434782608},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.006128702757916241},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"o":{"docs":{},"f":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"u":{"docs":{},"t":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"s":{"docs":{},"h":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},"i":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"x":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"l":{"docs":{},"y":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"p":{"docs":{},"h":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}},"e":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}},".":{"docs":{},"f":{"docs":{},"l":{"docs":{},"y":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"m":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}}},"\"":{"docs":{},")":{"docs":{},"나":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"m":{"docs":{},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017}}}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356}}}}}}},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"과":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"\"":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}}},"'":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{},"'":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"'":{"docs":{},"로":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"와":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"`":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"예":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}},"외":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"시":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}}}},":":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"를":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"나":{"docs":{},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}}},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},")":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"i":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}}}}}},"o":{"docs":{},"o":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"t":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}},"c":{"docs":{},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"∘":{"docs":{},"g":{"docs":{},")":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}}}},"v":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"a":{"docs":{},"r":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}}}}},"l":{"docs":{},"u":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}},"e":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"s":{"docs":{},")":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"i":{"docs":{},"d":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}},"{":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}}}}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105}}}}},"m":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"p":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}},"w":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}},"y":{"docs":{},"b":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}}}}},"여":{"docs":{},"기":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}},"그":{"docs":{},"리":{"docs":{},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"냥":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"즉":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"시":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"기":{"docs":{},"본":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"값":{"docs":{},")":{"docs":{},"을":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"은":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"다":{"docs":{},"른":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"아":{"docs":{},"래":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"를":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"역":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"(":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}},"y":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"명":{"docs":{},"확":{"docs":{},"한":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"타":{"docs":{},"입":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}},"은":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"프":{"docs":{},"로":{"docs":{},"그":{"docs":{},"래":{"docs":{},"머":{"docs":{},"에":{"docs":{},"게":{"docs":{},"는":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"에":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}},"s":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"|":{"docs":{},")":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"오":{"docs":{},"버":{"docs":{},"로":{"docs":{},"딩":{"docs":{},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"이":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}},"간":{"docs":{},"단":{"docs":{},"한":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}},"변":{"docs":{},"수":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"스":{"docs":{},"크":{"docs":{},"립":{"docs":{},"트":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},"전":{"docs":{},"역":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"인":{"docs":{},"용":{"docs":{},")":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"터":{"docs":{},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{},")":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}}}}}},"코":{"docs":{},"딩":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"만":{"docs":{},"약":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}},"함":{"docs":{},"수":{"docs":{},"형":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"!":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}},"i":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}},"#":{"docs":{},"메":{"docs":{},"타":{"docs":{},"데":{"docs":{},"이":{"docs":{},"터":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}},")":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"@":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}},"클":{"docs":{},"로":{"docs":{},"저":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"래":{"docs":{},"스":{"docs":{},"의":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}}}}},"확":{"docs":{},"장":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"모":{"docs":{},"듈":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"로":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"혹":{"docs":{},"은":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"밀":{"docs":{},"리":{"docs":{},"초":{"docs":{},")":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"값":{"docs":{},"과":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"네":{"docs":{},"임":{"docs":{},"스":{"docs":{},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}}}}}}},"디":{"docs":{},"렉":{"docs":{},"토":{"docs":{},"리":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}}}},"폴":{"docs":{},"트":{"docs":{},")":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}}},"공":{"docs":{},"통":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"윈":{"docs":{},"도":{"docs":{},"우":{"docs":{},")":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"유":{"docs":{},"닉":{"docs":{},"스":{"docs":{},")":{"docs":{},".":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"특":{"docs":{},"정":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}},"맨":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}}},"위":{"docs":{},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}}}},"+":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.02086677367576244},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.005426356589147287},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0033034450212364322},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.01927386822052891},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.008487654320987654},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.002958032908116103},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0027266530334014998},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.005988023952095809},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002962085308056872},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0017844396859386152},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.008344923504867872},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}}},"=":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}}},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"'":{"docs":{},"b":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"를":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},")":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},",":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"/":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"파":{"docs":{},"일":{"docs":{},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"와":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0050704225352112674},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0038580246913580245},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00258827879460159},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.003749147920927062},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.006745362563237774},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.007698887938408896},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"b":{"docs":{},"c":{"docs":{},"]":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"c":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"d":{"docs":{},"]":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"s":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},",":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"]":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"o":{"docs":{},"f":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},")":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"o":{"docs":{},",":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}},";":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333}}}},"/":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},".":{"docs":{},"/":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"@":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"@":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}},"e":{"docs":{},"/":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}},"#":{"docs":{},"{":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"}":{"docs":{},"/":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}}}}}}},"z":{"docs":{},"h":{"docs":{},"/":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"@":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"만":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"d":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}},"의":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"의":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}},"e":{"docs":{},"s":{"6":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}}},"j":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0035688793718772305},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}},"s":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},".":{"docs":{},"p":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}},")":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"도":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"파":{"docs":{},"일":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"o":{"docs":{},"n":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"와":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"p":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}}}}}}},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.004713275726630008}}}}}}}}}}},"'":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"b":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"{":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},".":{"docs":{},"/":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}},"(":{"docs":{},"{":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}},"u":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}}}}}}},"\"":{"docs":{},"t":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0040858018386108275}},"s":{"docs":{},"를":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},")":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0056457304163726185}},"가":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093}}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}},"o":{"docs":{},"g":{"docs":{},"(":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},")":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"docs":{},"\"":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},")":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}}}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"5":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"docs":{}}}}}}}}},"a":{"docs":{},"p":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}}},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"h":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.014098690835850957},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.014139827179890024},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.005361434645960436},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},")":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"(":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"=":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.01765650080256822},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.025923016496465043},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.013521126760563381},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.031007751937984496},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.032029950083194675},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.02412280701754386},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.026899480887210947},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.025997310623038995},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.009880028228652082},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.022997620935765267},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.017897091722595078},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.016975308641975308},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.02847106674061749},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.037037037037037035},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.025362318840579712},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.021131561008861623},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.02349336057201226},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.00505902192242833},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.008168028004667444},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.015402843601895734},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.020114942528735632},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006611570247933884},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.022840827980014276},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.05573080967402734},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.015994436717663423},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.014134275618374558},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.01434878587196468},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0364741641337386},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.010232558139534883}},"=":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176}},"=":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0022185246810870773},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00408997955010225},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{},"=":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.003811338732729871}}}}}}}}},">":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004930524428507396},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.013117283950617283},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.002958032908116103},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.002044989775051125},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.006417736289381563},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.017241379310344827},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0039257673090649535},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.004206098843322818},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.012482662968099861},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},">":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0028585040495474035},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}},">":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},">":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"=":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"[":{"0":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}},"1":{"0":{"docs":{},":":{"3":{"4":{"docs":{},":":{"2":{"0":{"docs":{},"]":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}},"1":{"docs":{},"]":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}},"docs":{}},"docs":{}}},"5":{"docs":{},":":{"2":{"2":{"docs":{},"]":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"4":{"docs":{},"]":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.010869565217391304},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}},"]":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"2":{"docs":{},"]":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"3":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"4":{"docs":{},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}},"7":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005673758865248227},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"\"":{"0":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"docs":{},"e":{"docs":{},"s":{"2":{"0":{"1":{"5":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}}}}},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"j":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"/":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"/":{"docs":{},"j":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}}}}},"*":{"docs":{},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}},"'":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"'":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"2":{"docs":{},"/":{"docs":{},"b":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"2":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"*":{"docs":{},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}}}}}}}}}},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"'":{"docs":{},"]":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"'":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{},"]":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"'":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}},"e":{"docs":{},"s":{"2":{"0":{"1":{"5":{"docs":{},"'":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},"y":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},"]":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}}},"로":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"]":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}},"y":{"docs":{},"m":{"docs":{},"]":{"docs":{},":":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},"]":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"a":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079}}},"]":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}},"]":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}}}}}},"e":{"docs":{},"w":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807}}},"]":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"p":{"3":{"docs":{},"]":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"4":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}},"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020336476243298205}},"r":{"docs":{},"o":{"docs":{},"p":{"4":{"docs":{},"]":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"5":{"docs":{},"=":{"4":{"2":{"docs":{},"]":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"docs":{}},"docs":{}}},"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}},"x":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}},"{":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"u":{"docs":{},"p":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}}}}}}}}}}}},"k":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}},"e":{"docs":{},"y":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{},"{":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}}}}}}}}}}}}}}}}}}},"노":{"docs":{},"드":{"docs":{},"]":{"docs":{},"[":{"docs":{},"#":{"docs":{},"노":{"docs":{},"드":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}},"클":{"docs":{},"래":{"docs":{},"식":{"docs":{},"]":{"docs":{},"[":{"docs":{},"#":{"docs":{},"클":{"docs":{},"래":{"docs":{},"식":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}},"메":{"docs":{},"타":{"docs":{},"데":{"docs":{},"이":{"docs":{},"터":{"docs":{},"]":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"4":{"docs":{},"]":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"5":{"docs":{},"=":{"4":{"2":{"docs":{},"]":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}}}},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"]":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}}}}}}}},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.010070493454179255}},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"y":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}},"[":{"docs":{},"]":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"나":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"로":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"에":{"docs":{},"서":{"docs":{},"의":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002962085308056872},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}}},"이":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"임":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"만":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"t":{"docs":{},"h":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"a":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0075507314771118455},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00427715996578272}},"a":{"docs":{},"l":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"#":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}},"g":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}},"과":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471}}},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"이":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}},"라":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"[":{"docs":{},"]":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154}}}},")":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"m":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"l":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}}}}}}}}},"의":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"d":{"docs":{},"x":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}}},"p":{"docs":{},"p":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017}},"s":{"docs":{},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}}}}}}}}},"i":{"docs":{},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}}}}}}}}}}}},"`":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}},"y":{"docs":{},"m":{"docs":{},"i":{"docs":{},"x":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}}}}}}}}}}}}},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},":":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"i":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"뿐":{"docs":{},"만":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"r":{"docs":{},"g":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0024982155603140615}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"[":{"0":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}},"1":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}},"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"]":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}}}}}},"라":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.009880028228652082}}},"가":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546}}},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732}}}},"r":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}},"a":{"docs":{},"y":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"(":{"5":{"2":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}}}},"docs":{}},"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"#":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"를":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}}}}},"이":{"docs":{},"나":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}}}}},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}},"o":{"docs":{},"w":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}},"e":{"docs":{},"a":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0021929824561403508}}},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}}}},"도":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"으":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"s":{"docs":{},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}},"n":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"x":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"i":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"a":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"a":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"을":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":5.008056394763344}}}}}}},"라":{"docs":{},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}}}}},"d":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}}},"d":{"1":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"(":{"docs":{},"x":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}}}},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"z":{"docs":{},"(":{"docs":{},"x":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"i":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"u":{"docs":{},"n":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"s":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}}},"j":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"s":{"docs":{},"에":{"docs":{},"만":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"와":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0031376064545047063}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}},"i":{"docs":{},"a":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"s":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"s":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}},")":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}}}}}}}},"b":{"docs":{},"u":{"docs":{},"m":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}},".":{"docs":{},"a":{"docs":{},"l":{"docs":{},"b":{"docs":{},"u":{"docs":{},"m":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"m":{"docs":{},"d":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.008264462809917356}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"t":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}}}},",":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"b":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.003965107057890563},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}},"a":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0027906976744186047}},"\"":{"docs":{},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},")":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"로":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"은":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},"을":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}}}},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"k":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}},"g":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"e":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}}}}}},"?":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}}}},"+":{"docs":{},"+":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0033277870216306157},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.004991680532445923},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0021413276231263384},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.006309148264984227},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"=":{"docs":{},"\"":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"라":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"와":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"[":{"1":{"0":{"docs":{},"]":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"docs":{}},"docs":{}},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.002831524303916942}}}}}}}},"(":{"docs":{},")":{"docs":{},"{":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}},"v":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"c":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"i":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.017241379310344827}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}}}},"을":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}}}}}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"u":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}},"g":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}}}}}}}},")":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"가":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"?":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},".":{"docs":{},"a":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"b":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},".":{"docs":{},"c":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"는":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"y":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}}}},"t":{"docs":{},"s":{"docs":{},"가":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"에":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}},"d":{"3":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}},".":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}},":":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}},"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"o":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"c":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},".":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},".":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008025682182985553}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"y":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"\"":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}}}}}}}}}}}}},"의":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}},"s":{"docs":{},"처":{"docs":{},"럼":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"m":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"\"":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},";":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"과":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}},"을":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"의":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}}},"이":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},",":{"docs":{},"e":{"docs":{},"s":{"5":{"docs":{},",":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}},"6":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},".":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}},".":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"'":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":5}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":5},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}},"s":{"docs":{},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"e":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"f":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}}}}}},"g":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},".":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"1":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"docs":{}},"docs":{}}}}}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},")":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}}},"w":{"docs":{},"n":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"m":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"l":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"'":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"s":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"e":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"b":{"docs":{},"u":{"docs":{},"g":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"g":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.007498295841854124},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"s":{"docs":{},"안":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}},"i":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}},"e":{"docs":{},"(":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"[":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}}}}},"\"":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},".":{"docs":{},"a":{"docs":{},"m":{"docs":{},"d":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}},"에":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"의":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}}},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}},"(":{"docs":{},"[":{"docs":{},"'":{"docs":{},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"/":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"*":{"docs":{},"*":{"docs":{},"/":{"docs":{},"*":{"docs":{},"'":{"docs":{},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}},"e":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.006128702757916241}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"y":{"docs":{},"에":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},"i":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517}}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}}}}},"v":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003927729772191673},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"를":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.003067484662576687},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004667444574095682},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.028268551236749116},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.012482662968099861},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0040858018386108275},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}},"k":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0044822949350067235}},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002962085308056872}}}}}}}}}}},"a":{"docs":{},"d":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}}}}}}}}}}}},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"e":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0035545023696682463}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.005257623554153523}}}}}}}}}},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}}},"k":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}},"e":{"docs":{},"p":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":5.001103752759382}}}},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}},"i":{"docs":{},"v":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"e":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":5}},")":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"s":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"/":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},"b":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}}}}},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}}}}}}}}}}},"의":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"폴":{"docs":{},"더":{"docs":{},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.014367816091954023}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}},"과":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}},"k":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.004758128469468675}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"u":{"docs":{},"p":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"]":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}}}}}}}}}}},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"y":{"docs":{},")":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"[":{"4":{"2":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"docs":{}},"docs":{},"'":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"'":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}}}}}}}}}}}},"f":{"docs":{},"f":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"(":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.005547850208044383}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"n":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}},"x":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},";":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"y":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"]":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.006128702757916241}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105}}}},"a":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"?":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}},"d":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}},".":{"docs":{},"t":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}},"?":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}},"o":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0182370820668693}},"(":{"docs":{},"_":{"docs":{},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}},"r":{"docs":{},"y":{"docs":{},")":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},":":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"o":{"docs":{},"p":{"docs":{},"을":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}}}}}}},"e":{"1":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"2":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.003965107057890563},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}}},"`":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}}}}}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},"!":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}}}},";":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},"d":{"docs":{},"g":{"docs":{},"e":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"i":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"o":{"docs":{},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},"s":{"docs":{},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}},"y":{"docs":{},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}}}}},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"e":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.004247286455875413}},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}}}}}}},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}},".":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}}}}}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471}}},"라":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"[":{"1":{"docs":{},"]":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"docs":{}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"을":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"n":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}},"y":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},".":{"docs":{},"t":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}},"i":{"docs":{},"r":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"e":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}},"u":{"docs":{},"m":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.004651162790697674},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0190325138778747},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},".":{"docs":{},"a":{"docs":{},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}}}}},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}}}}},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}}}}}},"s":{"docs":{},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.003965107057890563},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"과":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"e":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}},")":{"docs":{},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.007150153217568948}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"s":{"2":{"0":{"1":{"5":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003927729772191673},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"서":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"도":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"x":{"docs":{},"i":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},".":{"docs":{},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}}}}}}}},"6":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}}}},"7":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}},"docs":{}},"2":{"0":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"용":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"을":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"docs":{}},"docs":{}},"docs":{}},"3":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},")":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},",":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"5":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.010869565217391304},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},",":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"6":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0034770514603616135},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"서":{"docs":{},"는":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"가":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}},"로":{"docs":{},"도":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"7":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":10},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"e":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},"s":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},";":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}},":":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}},"p":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"l":{"docs":{},"i":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004796163069544364},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.033401499659168374},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.012257405515832482},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.01011804384485666},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.018819503849443968},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.01434878587196468},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0051162790697674414}},"\"":{"docs":{},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625}}},"c":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"_":{"1":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}},"docs":{}},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625}}},"도":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"와":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},"되":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"된":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"만":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"한":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"할":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"와":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"r":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"s":{"docs":{},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}},"은":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"는":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"와":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"은":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"[":{"1":{"docs":{},"]":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"docs":{}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"로":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"\"":{"docs":{},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}},"d":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0030701754385964912},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.004719207173194903},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0066555740432612314},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"s":{"docs":{},"의":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},")":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"를":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"(":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"/":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"r":{"docs":{},"n":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135}},"e":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"와":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0033349213911386373}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}},"l":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}},"e":{"docs":{},"p":{"docs":{},"h":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154}}}}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}},"s":{"docs":{},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841}}}},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"문":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"a":{"docs":{},"p":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"e":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"?":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}}}}}}}}},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"2":{"0":{"2":{"0":{"docs":{},"은":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"docs":{}},"docs":{}},"docs":{}},"3":{"docs":{},"에":{"docs":{},"서":{"docs":{},"도":{"docs":{},"!":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0027906976744186047}},"의":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}}}}}}},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}}}}},"h":{"docs":{},"o":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}},":":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}},"s":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},".":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"e":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376}}}}},"x":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"y":{"docs":{},")":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"g":{"docs":{},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"t":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},"e":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}}}},":":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"가":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"s":{"docs":{},"가":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"(":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},".":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}},"f":{"1":{"2":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"docs":{},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"x":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},")":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}},"2":{"docs":{},"(":{"docs":{},"x":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"5":{"docs":{},"키":{"docs":{},"를":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"i":{"docs":{},"l":{"docs":{},"e":{"1":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"2":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"3":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.003811338732729871},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.033707865168539325},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}},"]":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},":":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}},".":{"docs":{},"t":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"s":{"docs":{},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"와":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"의":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}},".":{"docs":{},"t":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"s":{"docs":{},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"'":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0040858018386108275}}},":":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},"b":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"만":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002689376961004034}},"e":{"docs":{},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.006420545746388443}}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"]":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"와":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"[":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"]":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},"[":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"\"":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}},"d":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"s":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"t":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821}},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"라":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"이":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"p":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"h":{"docs":{},"e":{"docs":{},"x":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}}}},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}},"e":{"docs":{},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"i":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008025682182985553},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.006042296072507553},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.009426551453260016},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0050704225352112674},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.003875968992248062},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.008735440931780365},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0035087719298245615},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00761990138951143},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.011997177134791814},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00887409872434831},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00408997955010225},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.005988023952095809},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004084014002333722},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.011848341232227487},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.008565310492505354},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.008412197686645636},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0034770514603616135},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.012367491166077738},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.024965325936199722},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"(":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"1":{"docs":{},")":{"docs":{},"{":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"docs":{}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922}},"{":{"docs":{},"}":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}},"r":{"docs":{},"c":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"x":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}}}}}}}}},"u":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695}}},":":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}}}}}},"y":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"_":{"1":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"docs":{}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}},"s":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.00530035335689046}}},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"과":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},">":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"e":{"docs":{},"s":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"e":{"docs":{},"s":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/declaration files/Templates.html":{"ref":"pages/declaration files/Templates.html","tf":0.07692307692307693}},"s":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"을":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}},"선":{"docs":{},"언":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}},"c":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"(":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"%":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203}},"은":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203}}}}},"o":{"docs":{},"f":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.025362318840579712}},"는":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.010869565217391304}}},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"c":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"o":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.00772626931567329},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}},"!":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"+":{"docs":{},"+":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}},"x":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821}}}},"i":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},".":{"docs":{},"d":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226}}}}}}}}}}},".":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"s":{"docs":{},"을":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},".":{"docs":{},"i":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"a":{"docs":{},"y":{"docs":{},"h":{"docs":{},"i":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}}},"j":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"a":{"docs":{},";":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}}}}}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"d":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0024958402662229617}}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"?":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}},"는":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"]":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"n":{"docs":{},"d":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"2":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"docs":{}}}}}}},"2":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"3":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"docs":{}}}}}}},"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}},"s":{"docs":{},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}}},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}}}}}}}}},"n":{"docs":{},"k":{"docs":{},"w":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"/":{"docs":{},"d":{"docs":{},"u":{"docs":{},"o":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}},"e":{"docs":{},"e":{"docs":{},"z":{"docs":{},"e":{"docs":{},"(":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"o":{"docs":{},"z":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}},"t":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}}}}},"w":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}}},"(":{"docs":{},"\"":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}}}}}}},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"은":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}}}}}}}},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}},"i":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"l":{"docs":{},"s":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.039297658862876256},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"e":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},",":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"]":{"docs":{},";":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"p":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}}}},"q":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"(":{"1":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}},"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}},"[":{"1":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}}}}}}}}}}},"n":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},"x":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}},"{":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079}},"}":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}},"g":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{},")":{"docs":{},"와":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"l":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0040858018386108275}},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},")":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}},"n":{"1":{"0":{"docs":{},"(":{"docs":{},"p":{"1":{"docs":{},")":{"docs":{},"{":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"docs":{}}}},"docs":{}},"6":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"7":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"9":{"docs":{},"(":{"docs":{},"p":{"1":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"docs":{}}}},"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"m":{"docs":{},"y":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}}}}}}}}},"x":{"docs":{},".":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"f":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}}}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.018030513176144243}}}}}},"와":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"c":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"s":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},"f":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},",":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"e":{"docs":{},"r":{"1":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"2":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008025682182985553},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.006134969325153374},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004146919431279621},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.01060070671378092}},"(":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.006420545746388443}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008025682182985553}}}}}}}},"\"":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471}}},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}}},"j":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215}},"s":{"docs":{},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215}},"s":{"docs":{},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}}}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"라":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"라":{"docs":{},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"(":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"n":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"e":{"docs":{},"w":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"y":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"@":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}},"g":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"e":{"docs":{},"t":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}},"{":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.007067137809187279}}},"\"":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},".":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}}}}}}},"k":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"e":{"docs":{},")":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"e":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},")":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}}}},"을":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}},"n":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837}}}}},"a":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}}}},"i":{"docs":{},"d":{"1":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"2":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"(":{"1":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"docs":{}}},"5":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"docs":{}}},"docs":{}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"y":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"a":{"docs":{},"p":{"docs":{},"h":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00911854103343465}},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"{":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"n":{"docs":{},"p":{"docs":{},"m":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"g":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}},"와":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},":":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968}}}}}}}}}},"과":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"x":{"docs":{},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546}}}},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},"i":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}}}}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"(":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}},"이":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"(":{"4":{"3":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"docs":{}},"docs":{},"\"":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"n":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}},"s":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}},"d":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"2":{"docs":{},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"3":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"docs":{}}}}}}},"docs":{}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}}},"l":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"f":{"docs":{},"n":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0035285815102328866}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546}}}}}}}}}}},"s":{"docs":{},")":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546}}}}}}}}},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.006042296072507553},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0204241948153967},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0121580547112462}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},".":{"docs":{},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"s":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"/":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"/":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}}}}}}}}}},"\"":{"docs":{},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"*":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}}}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"s":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"은":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}},"s":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386}}}}}}}},"(":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"b":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617}},"a":{"docs":{},"l":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.006258692628650904},"pages/declaration files/Templates.html":{"ref":"pages/declaration files/Templates.html","tf":0.15384615384615385}},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/declaration files/Templates.html":{"ref":"pages/declaration files/Templates.html","tf":0.07692307692307693}},"s":{"docs":{},"은":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}}}},"을":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},".":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"{":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"(":{"docs":{},"{":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}},"o":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"o":{"docs":{},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0043859649122807015},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.006128702757916241},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.005107252298263534}},"s":{"docs":{},"와":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.005995203836930456},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.026244035446489435},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.01011804384485666},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.010481181515007145},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.009735744089012517},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.006622516556291391},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.005107252298263534},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.009767441860465116}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"는":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"s":{"docs":{},"나":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"/":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"s":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}}}}}}},"나":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.005240590757503573},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.005240590757503573},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"문":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}},"할":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"하":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"지":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"/":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"의":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}}}},"(":{"docs":{},"\"":{"docs":{},".":{"docs":{},"/":{"docs":{},"a":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}},"x":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{},")":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},")":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"는":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}},"된":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}}},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0040858018386108275}}}}}},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"a":{"docs":{},"g":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"e":{"docs":{},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"i":{"docs":{},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"t":{"docs":{},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0054988216810683424},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004796163069544364},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.02127659574468085},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"l":{"docs":{},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"n":{"docs":{},"c":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"e":{"docs":{},"o":{"docs":{},"f":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}},"e":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.005257623554153523}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"\"":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}},"t":{"3":{"2":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}}}}},"docs":{}},"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.011403508771929825},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.005401234567901234},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0031429099648733593},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.006128702757916241},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.011976047904191617},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.007584597432905484},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.006309148264984227},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0088339222614841},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.008321775312066574},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.008830022075055188},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"e":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"s":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"d":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"j":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"을":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}},"t":{"docs":{},"s":{"docs":{},"x":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"가":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"j":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}},"s":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"s":{"docs":{},"이":{"docs":{},"고":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"와":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"?":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"i":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}}}}}}},"o":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"r":{"docs":{},"m":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0022185246810870773},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"[":{"0":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"1":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"docs":{}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}}}},"v":{"docs":{},"o":{"docs":{},"k":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"[":{"1":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}}}},"docs":{}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}}}}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},".":{"docs":{},"`":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}},"d":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}},"u":{"docs":{},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}}},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"(":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}}}}}}}}}}},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"과":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"'":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0040858018386108275}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}}}}}}},"'":{"docs":{},"l":{"docs":{},"l":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"m":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}},"문":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"s":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"x":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"x":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.003067484662576687},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.009193054136874362}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"e":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"docs":{},"x":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}}}}}},":":{"docs":{},"\"":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"i":{"docs":{},"f":{"docs":{},"e":{"docs":{},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.006351446718419196},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.006351446718419196}}}}}}},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0035285815102328866}}},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"와":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"!":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}},"에":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"a":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"를":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"(":{"docs":{},"x":{"docs":{},")":{"docs":{},"{":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"g":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"/":{"docs":{},"o":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"v":{"docs":{},"o":{"docs":{},"g":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"/":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}},"j":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"a":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"v":{"docs":{},"a":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.009630818619582664},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.007150153217568948},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":2.5021413276231264},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":5.00056338028169},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"처":{"docs":{},"럼":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"선":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"파":{"docs":{},"일":{"docs":{},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"처":{"docs":{},"럼":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}},"이":{"docs":{},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"(":{"docs":{},"유":{"docs":{},"사":{"docs":{},"한":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}},"i":{"docs":{},"r":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}},"s":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"x":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":10.01516919486581},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.004180602006688963},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004667444574095682},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"와":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},".":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004084014002333722}},";":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}},"[":{"docs":{},"]":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"가":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}},"서":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"y":{"docs":{},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881}}},"에":{"docs":{},"서":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.004282655246252677},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"을":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0021413276231263384}}}}}},"p":{"docs":{},"m":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}},"@":{"docs":{},"b":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}},"의":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},"o":{"docs":{},"n":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"에":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},"y":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"(":{"docs":{},"j":{"docs":{},"i":{"docs":{},"m":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"y":{"docs":{},".":{"docs":{},"#":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}},"e":{"docs":{},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.006420545746388443},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},";":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895}}},"?":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002631578947368421},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"e":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}},"e":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}},"y":{"docs":{},"e":{"docs":{},"g":{"docs":{},"g":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}},"r":{"docs":{},"g":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}},"i":{"docs":{},"b":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.008264462809917356},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"s":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968}}}},"i":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":5.002086230876217},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.005563282336578581}}}}}}}}},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"s":{"docs":{},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"와":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},",":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"가":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"n":{"docs":{},"k":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}},"e":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}},")":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}},"s":{"docs":{},"t":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837}}},"[":{"1":{"docs":{},"]":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"docs":{}},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196}}}}}}}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}}}}}}}}}}}},")":{"docs":{},"{":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}},"o":{"docs":{},"n":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"e":{"docs":{},"r":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"\"":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"'":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"서":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"s":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}},"가":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}}},"에":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}}}},"o":{"docs":{},"p":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"k":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"g":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"3":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0035285815102328866}}}}}},"{":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}}}}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"e":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"[":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}}}}}}}}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"i":{"docs":{},"c":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}},"n":{"docs":{},"g":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"e":{"docs":{},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"e":{"docs":{},"t":{"docs":{},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"과":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}},"문":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"선":{"docs":{},"언":{"docs":{},"만":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"s":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}},".":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"와":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}}}}}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"'":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}}},"g":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"f":{"docs":{},"t":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"a":{"docs":{},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},"f":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},"r":{"docs":{},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"u":{"docs":{},"c":{"docs":{},"a":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"f":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"m":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"i":{"docs":{},"d":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"까":{"docs":{},"지":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"p":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"s":{"docs":{},",":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}}}}}}},"m":{"docs":{},"s":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"를":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},":":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807}}}}}},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"s":{"docs":{},"s":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},")":{"docs":{},"\"":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}},"x":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.014367816091954023}},"을":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.011494252873563218}}},"의":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.014367816091954023}}}}}},"t":{"docs":{},"i":{"docs":{},"g":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"s":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"j":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"y":{"docs":{},"/":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"u":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}},"p":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.005995203836930456},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}},"(":{"docs":{},"f":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},".":{"docs":{},"t":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}},"s":{"docs":{},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"t":{"docs":{},"h":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"x":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"x":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617}}}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}}}}}}}}}}},"x":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}}}}}},"p":{"docs":{},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}}},"docs":{}}}}}}}}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},"c":{"docs":{},"h":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}},"}":{"docs":{},"`":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"k":{"docs":{},"e":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}},"{":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"의":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"와":{"docs":{},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}}}}}},"x":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"e":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"j":{"docs":{},"s":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"z":{"docs":{},"i":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004146919431279621}},"\"":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231}}}},")":{"docs":{},"를":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"라":{"docs":{},"이":{"docs":{},"브":{"docs":{},"러":{"docs":{},"리":{"docs":{},"를":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"d":{"2":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135}},"s":{"docs":{},")":{"docs":{},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"?":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}},"(":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498}}},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}}}}}}}},"a":{"docs":{},"n":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"t":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}}}},"e":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"s":{"docs":{},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.005107252298263534}},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"y":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"u":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.007157464212678937},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.005717008099094807},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.006954102920723227},"pages/declaration files/Templates.html":{"ref":"pages/declaration files/Templates.html","tf":0.23076923076923078},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"e":{"docs":{},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"에":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Templates.html":{"ref":"pages/declaration files/Templates.html","tf":0.15384615384615385}},"s":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.002044989775051125},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.00505902192242833},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"은":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"\"":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"a":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942}}}}}}}}}}}}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},")":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},":":{"docs":{},"m":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}}},"b":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"에":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"과":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"의":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"이":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"a":{"docs":{},"r":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968},"pages/declaration files/Templates.html":{"ref":"pages/declaration files/Templates.html","tf":0.07692307692307693}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"s":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}},"_":{"1":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499}}}}}}}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"_":{"1":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"docs":{}}},"docs":{}},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.00530035335689046}}}}}},"n":{"docs":{},"t":{"docs":{},"h":{"docs":{},".":{"docs":{},"\"":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"`":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"z":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}}}}},"v":{"docs":{},"e":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517}},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"d":{"docs":{},"x":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"e":{"docs":{},"v":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"가":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}},".":{"docs":{},"x":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"y":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}}}}}}},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}},".":{"docs":{},"j":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"s":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"에":{"docs":{},"서":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}}},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.006128702757916241}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"y":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}},"[":{"0":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"2":{"docs":{},"]":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"docs":{}}}},"o":{"docs":{},"w":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"d":{"docs":{},"d":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"f":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"x":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}}}}}}}}}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004667444574095682},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"가":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0030701754385964912}}}}}},"t":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}},"[":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},")":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0035285815102328866}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"과":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}},";":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"e":{"docs":{},".":{"docs":{},"d":{"docs":{},"o":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}},"i":{"docs":{},"b":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"를":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}}}}}}}}}}}}},"에":{"docs":{},"는":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"p":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}}}}}},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"k":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736}}}}}},"s":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0040858018386108275},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.01},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0121580547112462},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}},"에":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"서":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0425}},"의":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":3.333333333333333}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002631578947368421},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.005107252298263534}},"y":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"i":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"c":{"docs":{},"h":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0021413276231263384}},"e":{"docs":{},"w":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002631578947368421},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.011798017932987258},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0035285815102328866},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.013422818791946308},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014790164540580515},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.006475800954328562},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.007150153217568948},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.010214504596527068},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0027906976744186047}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"1":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"2":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}},"의":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},")":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.004651162790697674},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014790164540580515},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837}}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}},"타":{"docs":{},"입":{"docs":{},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"을":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}}}},"x":{"docs":{},"t":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"e":{"docs":{},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.007150153217568948}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"p":{"docs":{},"m":{"3":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.007855459544383346},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.009592326139088728},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.013333333333333334},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.02824858757062147},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0182370820668693},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},"과":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}},"에":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333}}},"으":{"docs":{},"로":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"의":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"x":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"u":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00911854103343465},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}},"과":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"를":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"에":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}},"l":{"docs":{},"l":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.005426356589147287},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0017844396859386152},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}},"과":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014790164540580515},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"(":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"]":{"docs":{},";":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}},"'":{"docs":{},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"이":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"이":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}},"에":{"docs":{},"서":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"m":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.006201550387596899},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004034065441506051},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0035285815102328866},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0036975411351451285},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0035688793718772305},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.004206098843322818},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"(":{"docs":{},"이":{"docs":{},")":{"docs":{},"거":{"docs":{},"나":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0030701754385964912},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002689376961004034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.006934812760055479}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"[":{"docs":{},"]":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0061403508771929825},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0027731558513588465},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00427715996578272},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.00530035335689046},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.011095700416088766},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.008830022075055188},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"}":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"[":{"docs":{},"]":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},")":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}},"[":{"docs":{},"]":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0043859649122807015},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.003585835948005379},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0016638935108153079},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.007360672975814932},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.005547850208044383}}},"]":{"docs":{},"'":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"라":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}}}}}},"}":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"타":{"docs":{},"입":{"docs":{},"엔":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"와":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}},"'":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"일":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"s":{"docs":{},")":{"docs":{},"{":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}},".":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}}}}}}}}}},"는":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}}},"=":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"|":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}}}}}}}}},"s":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}}}}}},"e":{"docs":{},"g":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"e":{"docs":{},"r":{"docs":{},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.006128702757916241},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.005663048607833884},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0038580246913580245},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},")":{"docs":{},";":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"o":{"docs":{},"f":{"docs":{},"a":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}}}},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}},"d":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},"만":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}},"!":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"docs":{}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"docs":{}}}}}}}}},"?":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"e":{"docs":{},"r":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.002044989775051125},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.008171603677221655},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004084014002333722},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.00530035335689046},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.00772626931567329}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0040858018386108275},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"를":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},")":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}}}}},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"n":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}},"e":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}},"s":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"v":{"docs":{},"i":{"docs":{},"g":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},".":{"docs":{},"j":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0033349213911386373},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"s":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"에":{"docs":{},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"만":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0028585040495474035}}},"나":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"/":{"docs":{},"i":{"docs":{},"o":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"s":{"docs":{},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"파":{"docs":{},"일":{"docs":{},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}}}}},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"j":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"s":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"e":{"docs":{},"s":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"에":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"/":{"docs":{},"@":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}}}}}},"안":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"의":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}}}}}}}}}},"]":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"!":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"\"":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"y":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},":":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}}}}}},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"s":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"s":{"docs":{},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"y":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}},"e":{"docs":{},".":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}}}}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}}}}}},"o":{"docs":{},"k":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"n":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"e":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"e":{"docs":{},"s":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"e":{"docs":{},"s":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}}}}}}}}}}},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"가":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"을":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}},"w":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"s":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},".":{"docs":{},"c":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"d":{"docs":{},"s":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":5.023041474654378}},"e":{"docs":{},"s":{"docs":{},"는":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}}},"o":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"o":{"docs":{},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"p":{"docs":{},"s":{"docs":{},"!":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"1":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"2":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"s":{"docs":{},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}}}},"v":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"1":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"2":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"3":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"5":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"docs":{}}}}}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"?":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}},"b":{"docs":{},"j":{"2":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0031007751937984496},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"보":{"docs":{},"다":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"z":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"\"":{"docs":{},"}":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"s":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"}":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"나":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},")":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}}}}}}},"타":{"docs":{},"입":{"docs":{},"을":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}},"x":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"b":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"i":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"5":{"docs":{},",":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"docs":{}}}}}}}}},"[":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},"]":{"docs":{},"로":{"docs":{},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.006843455945252352}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}},"에":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}}}}}}}}}},"t":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323}}}},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0040858018386108275},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.015321756894790603}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},")":{"docs":{},"을":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"\"":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"'":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"과":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"로":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},":":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471}},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}}}},"l":{"docs":{},"d":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}}},".":{"docs":{},"a":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"b":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"x":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079}}},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}},"g":{"docs":{},"a":{"docs":{},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"에":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0040858018386108275}}}}}},"n":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.005107252298263534}},"c":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"b":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"y":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}}},"a":{"docs":{},"l":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"[":{"docs":{},"n":{"docs":{},"]":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"]":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}}}},"w":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}},"f":{"docs":{},"f":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"k":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}},";":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"#":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}}}}}}}},"p":{"0":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}}}}}}},"1":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}},".":{"docs":{},"x":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"(":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}}}}}}},"2":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"3":{"docs":{},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"4":{"docs":{},")":{"docs":{},"{":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"1":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"e":{"docs":{},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.004206098843322818},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},"s":{"docs":{},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}},";":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.005257623554153523}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"e":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"h":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"i":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"a":{"docs":{},"l":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}}}}}}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"처":{"docs":{},"럼":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},")":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}},"y":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"[":{"docs":{},"]":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}},"e":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"?":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"라":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"안":{"docs":{},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"에":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},"도":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"이":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"가":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}},"s":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"c":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}}}},")":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}},"g":{"docs":{},"e":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"s":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}},"t":{"docs":{},"h":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"?":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}},"s":{"docs":{},"[":{"2":{"docs":{},"]":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"docs":{}}},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"_":{"docs":{},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"\"":{"docs":{},"이":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},".":{"docs":{},"b":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"c":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}}}}}}}},"에":{"docs":{},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"i":{"docs":{},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215}}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},";":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.004815409309791332}}},"(":{"docs":{},"\"":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"'":{"docs":{},"j":{"docs":{},"i":{"docs":{},"m":{"docs":{},"'":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}},"에":{"docs":{},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"[":{"docs":{},"'":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"'":{"docs":{},"]":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}},"p":{"docs":{},"]":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}},"]":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"?":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"k":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.010869565217391304},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},".":{"docs":{},"f":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{},"e":{"docs":{},"g":{"docs":{},"g":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}}}}}}}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"s":{"docs":{},")":{"docs":{},"{":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203}}}},"[":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},"]":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}}}}}}}}}}}},"l":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"a":{"docs":{},"y":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}}}}}},"c":{"docs":{},"e":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"u":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"o":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},"i":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}}}}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"처":{"docs":{},"럼":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Templates.html":{"ref":"pages/declaration files/Templates.html","tf":0.15384615384615385}}}}}},"s":{"docs":{},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.004815409309791332},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"으":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"s":{"docs":{},"h":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":10}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"l":{"docs":{},"l":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}}}}},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"3":{"docs":{},"d":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0035545023696682463}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"l":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"p":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"m":{"docs":{},"이":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}},"g":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}}}}},"e":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0040858018386108275}},"e":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"g":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"z":{"docs":{},"i":{"docs":{},"l":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.033707865168539325}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"2":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"docs":{}}}}}}},"2":{"docs":{},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"3":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"docs":{}}}}}}},"docs":{}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"2":{"docs":{},"/":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"3":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"docs":{}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"'":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}},"s":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}},";":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"$":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"/":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"라":{"docs":{},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"의":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"e":{"docs":{},"과":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"(":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}},"p":{"1":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"2":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"3":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"?":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029171528588098016},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"s":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}},"\"":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231}}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004146919431279621}}}}}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"s":{"docs":{},"의":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},";":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"나":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"와":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"a":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"b":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"'":{"docs":{},"은":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.004719207173194903},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}},"와":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"?":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}},"x":{"docs":{},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"f":{"docs":{},"i":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"y":{"docs":{},"(":{"docs":{},"o":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"y":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}}}}}}}}}}}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"o":{"docs":{},"f":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"s":{"docs":{},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}}}},"b":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"s":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"s":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"r":{"docs":{},"v":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"m":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"n":{"docs":{},"c":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}}}}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}},"[":{"1":{"docs":{},"]":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"docs":{}}},"i":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"e":{"docs":{},"r":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}},".":{"docs":{},"h":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.006128702757916241}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}}}},"n":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}},"(":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}}}}}}}},"m":{"docs":{},"y":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}}}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}},"m":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.003947368421052632},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0070788107597923545},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0035545023696682463},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0051162790697674414}},"e":{"docs":{},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"으":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"지":{"docs":{},"정":{"docs":{},"자":{"docs":{},"와":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"프":{"docs":{},"로":{"docs":{},"퍼":{"docs":{},"티":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"c":{"docs":{},"y":{"docs":{},")":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"\"":{"docs":{},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"m":{"docs":{},"a":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}},".":{"docs":{},"i":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"x":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"i":{"docs":{},"e":{"docs":{},"c":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"c":{"docs":{},"k":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"(":{"1":{"5":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}},"docs":{}},"docs":{},"x":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"1":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}}},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}}}}}}},"2":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}}},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}}}}}}},"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004930524428507396}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}}}}},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}}}}}}}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}}}},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617}}}}}}}},">":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},";":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},"{":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"t":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},")":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}},"r":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}},"e":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008025682182985553},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.007855459544383346},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.005407653910149751},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0035087719298245615},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.004719207173194903},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.01165396683101748},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.013408609738884969},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.008689221667591052},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.005794137695978187},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.006128702757916241},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.005988023952095809},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004084014002333722},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.011255924170616114},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0017844396859386152},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.005257623554153523},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.004206098843322818}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.005257623554153523}}}}}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625}}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0034770514603616135},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}},"t":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{},"y":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.004713275726630008}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}}}},"\"":{"docs":{},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}},"t":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},";":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}},"/":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}}},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"x":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}},"a":{"docs":{},"g":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}},"y":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"/":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"/":{"docs":{},"b":{"docs":{},"a":{"docs":{},"z":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}},"d":{"docs":{},"u":{"docs":{},"o":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"[":{"docs":{},"\"":{"docs":{},".":{"docs":{},"/":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"s":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}},"j":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"m":{"docs":{},"d":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"는":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"를":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},".":{"docs":{},"j":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"에":{"docs":{},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}},"은":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"이":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}},"(":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}},"를":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"와":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"를":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"에":{"docs":{},"서":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"을":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"s":{"docs":{},"t":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},"o":{"docs":{},"r":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"f":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}}}}}}}}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"1":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895}}},"2":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895}}},"3":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895}}},"4":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0030701754385964912},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"[":{"docs":{},"k":{"docs":{},"]":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}},"s":{"docs":{},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356}},"e":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},"u":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}}}}}}}},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}}}}}}}},"s":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"e":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},".":{"docs":{},"y":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.016786570743405275},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005834305717619603},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"!":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},"\"":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}},"과":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},"가":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}}}}}}},"기":{"docs":{},"본":{"docs":{},"값":{"docs":{},")":{"docs":{},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},"x":{"docs":{},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}}}}}}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736}}},"와":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}},"d":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135}}},"y":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}}}}}}}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"키":{"docs":{},"워":{"docs":{},"드":{"docs":{},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"y":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"`":{"docs":{},"과":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029171528588098016}}}}}},"a":{"docs":{},"m":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}},"p":{"docs":{},"o":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0040858018386108275}},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}},"d":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"u":{"docs":{},"c":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},"e":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"와":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}}}}}},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"}":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}},"f":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}},"e":{"docs":{},"r":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.012257405515832482},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.006128702757916241}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},";":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},":":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}},"?":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004739336492890996}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},":":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"(":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}}},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"c":{"1":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702}}},"docs":{}},"u":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.005107252298263534}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}},"e":{"docs":{},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"o":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"5":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"docs":{}}}}}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"[":{"0":{"docs":{},"]":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"docs":{}},"l":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}},"o":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}},"s":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"[":{"2":{"docs":{},"]":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"docs":{}}}}}},"s":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}}}}}}},"m":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}}}}}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154}}}}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"가":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}}},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"u":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"n":{"docs":{},"g":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"e":{"docs":{},"는":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},">":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},")":{"docs":{},"와":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}},"s":{"1":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"2":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.006128702757916241},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}},"a":{"docs":{},"m":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"p":{"docs":{},"l":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}}},")":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}}}}},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}},"m":{"docs":{},"i":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"u":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"e":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}},"y":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}},"(":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"y":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}}}}},"v":{"docs":{},"e":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003927729772191673},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004796163069544364},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}},"w":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"k":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0069767441860465115},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.009983361064891847},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0040858018386108275},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0017844396859386152},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.007360672975814932},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.015050167224080268},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.004815409309791332},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.008494572911750826},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014790164540580515},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0034083162917518746},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.006128702757916241},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.00533175355450237},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0040858018386108275},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.00530035335689046},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.008321775312066574}}},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}}},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"으":{"docs":{},"로":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004034065441506051},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0035545023696682463},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0032119914346895075},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.013869625520110958}}},";":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008025682182985553},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004796163069544364},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.008771929824561403},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0075507314771118455},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002689376961004034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0038580246913580245},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0016638935108153079},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0027266530334014998},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029171528588098016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002962085308056872},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.00946372239747634},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.014134275618374558},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.005547850208044383},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},")":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"에":{"docs":{},"는":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"[":{"docs":{},"]":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705}},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"\"":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}}},"으":{"docs":{},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"'":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"]":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},"i":{"docs":{},"c":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}}}}}}}}}}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"나":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},">":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}}},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"라":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"혹":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}}},"에":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625}}}}}}}}}}},")":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"1":{"docs":{},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"docs":{}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0034083162917518746},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.008171603677221655}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"{":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}}}}}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"'":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},")":{"docs":{},";":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},"r":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"s":{"docs":{},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"`":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"이":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"e":{"docs":{},"s":{"docs":{},"을":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"가":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"이":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}}}},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"을":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"a":{"docs":{},"l":{"docs":{},"[":{"1":{"docs":{},"]":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"docs":{}}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}}}}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":5},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.005107252298263534}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215}},"(":{"docs":{},"\"":{"docs":{},"j":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.004815409309791332},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"과":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"게":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"u":{"docs":{},"p":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}}},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"t":{"docs":{},"e":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"은":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}}}}}},"라":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"i":{"docs":{},"c":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147}},"s":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"y":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"e":{"docs":{},"p":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"s":{"docs":{},")":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}},"라":{"docs":{},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}}}}}}},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"docs":{}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}},"e":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}},"o":{"docs":{},"r":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"(":{"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}}}}}}}}},":":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}}}}}}}}},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}},"o":{"docs":{},"u":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"s":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"e":{"docs":{},"(":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"s":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"]":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"라":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"[":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"]":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"[":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}},"선":{"docs":{},"언":{"docs":{},"과":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807}}}}}}}}}},"l":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004146919431279621},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.008171603677221655},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"예":{"docs":{},"제":{"docs":{},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"(":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}}},"(":{"docs":{},"d":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"가":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},":":{"docs":{},"[":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"에":{"docs":{},"서":{"docs":{},"만":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"[":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}}}}}},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},"과":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"(":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}}}}}}}}},"p":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"a":{"docs":{},"r":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}},"e":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.005107252298263534}}}},"h":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"m":{"docs":{},"s":{"docs":{},"은":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"o":{"docs":{},"w":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"(":{"docs":{},"\"":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"이":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.00505902192242833}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},".":{"docs":{},"c":{"docs":{},"i":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}}}}}}}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"s":{"docs":{},".":{"docs":{},"p":{"docs":{},"o":{"docs":{},"l":{"docs":{},"y":{"docs":{},"g":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},"'":{"docs":{},"와":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}}}}}}},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}}}}}}}}},"?":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}}}},"t":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}}}}}}}}},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887}}}}}}}}}}}}}}},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373}}},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}},"i":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}},"f":{"docs":{},"i":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"d":{"docs":{},"e":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"s":{"docs":{},")":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"r":{"docs":{},"e":{"docs":{},")":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}},"s":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}},"z":{"docs":{},"e":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"(":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"g":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"{":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"'":{"docs":{},")":{"docs":{},".":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},".":{"docs":{},"/":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"(":{"docs":{},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"에":{"docs":{},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"[":{"docs":{},"\"":{"docs":{},".":{"docs":{},"/":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"\"":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}},"s":{"docs":{},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"나":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"를":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"인":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"m":{"1":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}},"2":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.012345679012345678}}},"3":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}},";":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}},"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"(":{"docs":{},"\"":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.012345679012345678}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}},")":{"docs":{},";":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.012345679012345678}}}}},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.018115942028985508}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"프":{"docs":{},"로":{"docs":{},"퍼":{"docs":{},"티":{"docs":{},"에":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}}}},"s":{"docs":{},")":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}},"생":{"docs":{},"성":{"docs":{},"자":{"docs":{},"를":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}},"은":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"된":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"s":{"docs":{},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},")":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"!":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.009426551453260016},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0040858018386108275}},"e":{"docs":{},"(":{"docs":{},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"s":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}},"도":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"이":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"을":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}}}}},"r":{"docs":{},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"는":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}},")":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"(":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}},"t":{"docs":{},"h":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"y":{"docs":{},"p":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"과":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"y":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}},".":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}},"v":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}},"r":{"docs":{},"c":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.005107252298263534}},"/":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"s":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"t":{"docs":{},"s":{"docs":{},"c":{"docs":{},"/":{"docs":{},"t":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}},"_":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}}}}}}}}}}}}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105}}}}}}}}}}}}}}},":":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},"u":{"docs":{},"d":{"docs":{},"o":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"m":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"(":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}}}}}}}}}}}}}},"(":{"docs":{},"/":{"docs":{},"*":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"b":{"1":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"docs":{},")":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}}},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},"\"":{"docs":{},"이":{"docs":{},"라":{"docs":{},"고":{"docs":{},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}}}}},"i":{"docs":{},"t":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}},"\"":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004034065441506051}}},"s":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895}}},"[":{"docs":{},"p":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"]":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}},"r":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}},")":{"docs":{},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"블":{"docs":{},"록":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"m":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"i":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.005107252298263534},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"a":{"docs":{},"l":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"e":{"1":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}}}},"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"1":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}},"과":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0017844396859386152}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}}},"e":{"docs":{},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}}},")":{"docs":{},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"n":{"docs":{},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}},"q":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}}}}}}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002631578947368421}},")":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"(":{"1":{"0":{"0":{"docs":{},")":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"?":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}},")":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"\"":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.02586206896551724}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"e":{"docs":{},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"r":{"docs":{},"q":{"docs":{},"/":{"docs":{},"t":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"m":{"docs":{},"i":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}},")":{"docs":{},"]":{"docs":{},";":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154}}}}}},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"와":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},")":{"docs":{},"[":{"docs":{},"]":{"docs":{},"과":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}}},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}}}}}}},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"u":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}}}}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0023858214042263124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"f":{"docs":{},"c":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"를":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}}},"b":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"n":{"2":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"u":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0031429099648733593}},"p":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.006128702757916241}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"o":{"docs":{},"(":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"o":{"1":{"docs":{},",":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"docs":{},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}}}}}}}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}}},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"s":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.017364657814096015},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"e":{"docs":{},"r":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008025682182985553},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"\"":{"docs":{},";":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215}}}},"s":{"docs":{},"'":{"docs":{},",":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"와":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"j":{"docs":{},"s":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}},"?":{"docs":{},")":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"v":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"e":{"docs":{},")":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}}}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}}},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.004713275726630008}}},"y":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"c":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}}},"b":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}}}}}}}}}}}},"f":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"m":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.017385257301808066}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"를":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"가":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"로":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},")":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.005426356589147287},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0021413276231263384},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"e":{"docs":{},"d":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0022185246810870773},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"?":{"docs":{},"]":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}}}},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"을":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"'":{"docs":{},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},">":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"라":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"와":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"나":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"s":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"u":{"docs":{},"s":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"은":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}},"[":{"docs":{},"]":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"을":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"e":{"docs":{},"d":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},">":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"[":{"docs":{},"]":{"docs":{},">":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},">":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"x":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}}}},"t":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}}},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"i":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"h":{"docs":{},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{},"b":{"docs":{},"a":{"docs":{},"d":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695}},"가":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"는":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}}}},"n":{"docs":{},"t":{"3":{"2":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}}}},"docs":{}},"docs":{}}}},")":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"[":{"docs":{},"]":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"r":{"docs":{},"l":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"w":{"docs":{},"w":{"docs":{},"w":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"v":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"i":{"docs":{},"s":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008025682182985553},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{},"i":{"docs":{},"o":{"2":{"0":{"1":{"5":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"n":{"docs":{},"y":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.004713275726630008}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"e":{"docs":{},"w":{"1":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"2":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}},"a":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"o":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}},"a":{"docs":{},"r":{"9":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.006042296072507553},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.024351924587588374},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0050704225352112674},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.007903494176372712},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0027266530334014998},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004667444574095682},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.017130620985010708},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.011821974965229486},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.009708737864077669},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.030395136778115502}},"대":{"docs":{},"신":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"보":{"docs":{},"다":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"선":{"docs":{},"언":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"와":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"를":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"문":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"l":{"docs":{},"u":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014790164540580515},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},";":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0035545023696682463}}}}},"i":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0034083162917518746},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.007150153217568948}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},")":{"docs":{},".":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}}}}}}}}}}}}}}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}}}}}}}}}}}}}}}}}}}}},"{":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0040858018386108275}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}},"[":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"]":{"docs":{},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}}}}}}}}}}}}}}}}}}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}}}}}}}}}}}}}},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0031007751937984496},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135}},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.007067137809187279},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.009708737864077669}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"처":{"docs":{},"럼":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},">":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"일":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},">":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}}}}},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"과":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},"s":{"2":{"0":{"1":{"5":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}},"7":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.013824884792626729}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"와":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"s":{"1":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.013824884792626729}}},"docs":{}}}}}}}}}}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"e":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},"?":{"docs":{},":":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}}},")":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"i":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"w":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"e":{"docs":{},"b":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.007194244604316547},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}}}}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"은":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}}},"이":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"l":{"docs":{},"l":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},".":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}},"'":{"docs":{},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}},"v":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"a":{"docs":{},"k":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"은":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"을":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}}}}}}}},"w":{"docs":{},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"e":{"docs":{},"d":{"docs":{},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}},"y":{"docs":{},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}},"y":{"docs":{},"(":{"docs":{},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"(":{"docs":{},"{":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},":":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"란":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}},"?":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"r":{"docs":{},"n":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"i":{"docs":{},"t":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"l":{"docs":{},"k":{"docs":{},"(":{"docs":{},"p":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"n":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}}}},"s":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"y":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"s":{"docs":{},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.003500583430571762}},"!":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"\"":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"\"":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"\"":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"인":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}},")":{"docs":{},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.00530035335689046}}}}}}},"d":{"docs":{},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"k":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0040858018386108275}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"s":{"docs":{},",":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}},"r":{"docs":{},"i":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"o":{"docs":{},"f":{"docs":{},"!":{"docs":{},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}},"u":{"docs":{},"l":{"docs":{},"d":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}}}},"e":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}}},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"라":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"r":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}},"a":{"docs":{},"t":{"docs":{},"'":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}},"?":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807}}}},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.00530035335689046}},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"[":{"docs":{},"]":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},";":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"을":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695}},"l":{"docs":{},"에":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}}}}}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}},"가":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}}}}},",":{"docs":{},"x":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"{":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.016051364365971106},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.023162134944612285},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.019638648860958365},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.014647887323943662},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.016786570743405275},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.003875968992248062},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.03333333333333333},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.034922133081642284},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.021515015688032272},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.02117148906139732},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.022204599524187154},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.011185682326621925},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.016975308641975308},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.025143279718986875},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00823045267489712},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.032719836400818},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.03575076608784474},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.01011804384485666},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.00857551214864221},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.041060735671514116},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.025087514585764293},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.03495260663507109},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.05747126436781609},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.008264462809917356},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.016773733047822984},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.03470031545741325},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.008344923504867872},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.022968197879858657},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.015256588072122053},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.02869757174392936},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.008},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.02127659574468085},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0040858018386108275},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.03343465045592705},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.017674418604651163}},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"}":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"}":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105}}}}}}}},"m":{"docs":{},"y":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"}":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"}":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}},"{":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0021413276231263384}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},"}":{"docs":{},"}":{"docs":{},"`":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}}}},"a":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"(":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"s":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}},"}":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},")":{"docs":{},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},";":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"이":{"docs":{},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"와":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"}":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}}}},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"}":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"}":{"docs":{},"!":{"docs":{},";":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"}":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}}}},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"}":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"}":{"docs":{},"!":{"docs":{},";":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}}}}}}},"o":{"docs":{},"o":{"docs":{},"}":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"0":{"docs":{},")":{"docs":{},"}":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"docs":{}}}}}}}}}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"f":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617}}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}},"t":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"1":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"=":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.004996431120628123}}}}}}}}},"x":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}},"=":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}}}},"[":{"docs":{},"]":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.004282655246252677},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"}":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"}":{"docs":{},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"y":{"docs":{},"}":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}}}}}}}}}},"\"":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"[":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}}}}}}},"i":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}},"!":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"s":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}},"*":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}}}}}}}},"?":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}}}}}}},"k":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}}}}}},"}":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.014446227929373997},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.011077542799597181},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.009426551453260016},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.009577464788732394},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.011990407673860911},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.004651162790697674},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.01622296173044925},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.02982456140350877},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.033978291647003306},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.016136261766024205},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.019054340155257588},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0190325138778747},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.014660493827160493},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.023109632094657055},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00823045267489712},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.021739130434782608},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.02794819359236537},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.03983656792645557},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.01011804384485666},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.008099094807050978},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.041060735671514116},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.023337222870478413},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.03376777251184834},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.04597701149425287},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.015346181299072092},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.01892744479495268},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.006258692628650904},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.022968197879858657},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.015256588072122053},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.02207505518763797},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.008},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.018439716312056736},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.015197568389057751},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.01581395348837209}},";":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0029118136439267887},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0021929824561403508},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004034065441506051},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.00946372239747634},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0033112582781456954},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.006042296072507553},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.006284367635506678},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0027266530334014998},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.011494252873563218},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.00530035335689046},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00911854103343465}}},".":{"docs":{},"p":{"docs":{},"l":{"docs":{},"u":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}},"}":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},")":{"docs":{},";":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0033802816901408453},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.004206098843322818},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"과":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"[":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"o":{"docs":{},"f":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}},"]":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},">":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"\"":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}},"`":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}}}},"인":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"'":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},".":{"docs":{},"`":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0021413276231263384}}},"와":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}},"간":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}},"단":{"docs":{},"한":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.004815409309791332},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"하":{"docs":{},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"히":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"해":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"주":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}}},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"하":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"지":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"할":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"구":{"docs":{},"체":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}},")":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"되":{"docs":{},"기":{"docs":{},"에":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"결":{"docs":{},"하":{"docs":{},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"접":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"략":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}},"격":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}},"갖":{"docs":{},"고":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0021929824561403508},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.00530035335689046},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"\"":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"\"":{"docs":{},"와":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}},"지":{"docs":{},"원":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}},";":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"춰":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"게":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}}},"도":{"docs":{},"록":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"같":{"docs":{},"은":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.009577464788732394},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.004651162790697674},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.004159733777038269},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.004824561403508772},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0018487705675725643},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.002044989775051125},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.006669842782277275},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.005988023952095809},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006611570247933884},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0017844396859386152},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.006954102920723227},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0037209302325581397}},")":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"이":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003927729772191673},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0023820867079561697},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.004867872044506259},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.013824884792626729},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"아":{"docs":{},"야":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}},"보":{"docs":{},"이":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"다":{"docs":{},"고":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"으":{"docs":{},"므":{"docs":{},"로":{"docs":{},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},"음":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"도":{"docs":{},"록":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"개":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"수":{"docs":{},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"가":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"발":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}},"자":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"가":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"들":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"인":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"할":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"을":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"요":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"정":{"docs":{},"된":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"념":{"docs":{},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"지":{"docs":{},"만":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"들":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"을":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},"으":{"docs":{},"로":{"docs":{},"의":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"은":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}},"과":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}},",":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},"방":{"docs":{},"되":{"docs":{},"어":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"별":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"인":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"체":{"docs":{},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"든":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"객":{"docs":{},"체":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0029118136439267887},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0030701754385964912},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00823045267489712},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.004282655246252677},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002631578947368421},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.012345679012345678},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0023858214042263124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.007067137809187279},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"는":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.012345679012345678},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.021739130434782608},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0021929824561403508},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00823045267489712},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"들":{"docs":{},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"마":{"docs":{},"다":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"인":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}},"라":{"docs":{},"고":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}},"지":{"docs":{},"향":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"만":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"(":{"docs":{},"여":{"docs":{},"기":{"docs":{},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}},"쳬":{"docs":{},"지":{"docs":{},"향":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}},"것":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004796163069544364},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}},"만":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"으":{"docs":{},"로":{"docs":{},"도":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}},"은":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0024958402662229617},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002631578947368421},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006611570247933884},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.004815409309791332},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.003943661971830986},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004796163069544364},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0031007751937984496},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.005407653910149751},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0035087719298245615},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004034065441506051},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.004234297812279464},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020336476243298205},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.003943661971830986},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.008},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"라":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"면":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"도":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"므":{"docs":{},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"든":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"기":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"며":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0029118136439267887},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002631578947368421},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.003585835948005379},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0036975411351451285},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.00505902192242833},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029171528588098016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.008620689655172414},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0032119914346895075},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0027906976744186047}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"즉":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"각":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"다":{"docs":{},"행":{"docs":{},"히":{"docs":{},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"대":{"docs":{},"신":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"이":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"종":{"docs":{},"종":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"첫":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"파":{"docs":{},"일":{"docs":{},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},";":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"!":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"만":{"docs":{},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},")":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},",":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"까":{"docs":{},"?":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"들":{"docs":{},"에":{"docs":{},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"의":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"도":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"과":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0024982155603140615},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"인":{"docs":{},"지":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"처":{"docs":{},"럼":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},")":{"docs":{},"과":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"뿐":{"docs":{},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"부":{"docs":{},"터":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"보":{"docs":{},"다":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}},"결":{"docs":{},"과":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356}}},"물":{"docs":{},"은":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841}}},"을":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"정":{"docs":{},"할":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"되":{"docs":{},"거":{"docs":{},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"면":{"docs":{},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}},"해":{"docs":{},"야":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"합":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}},"하":{"docs":{},"여":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"면":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},"해":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}},"될":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"되":{"docs":{},"어":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"한":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"을":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"(":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},"을":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}},"된":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"함":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"경":{"docs":{},"고":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},"우":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.006197183098591549},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0031007751937984496},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0055511498810467885},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0035545023696682463},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00851063829787234},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.002044989775051125},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00427715996578272},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.003500583430571762},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0035688793718772305},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.008321775312066574},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"도":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"엔":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"와":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},")":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},"인":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"라":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}}},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0225}},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"가":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"에":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"로":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"일":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}},"험":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"보":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"향":{"docs":{},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}}},"계":{"docs":{},"약":{"docs":{},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},")":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}}}}},"속":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003927729772191673},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"해":{"docs":{},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"획":{"docs":{},"이":{"docs":{},"라":{"docs":{},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"산":{"docs":{},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"되":{"docs":{},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"된":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0055511498810467885},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}},"기":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"됨":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}}},"층":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"적":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"으":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"에":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"과":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}},"관":{"docs":{},"련":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"된":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"되":{"docs":{},"어":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},")":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"사":{"docs":{},"항":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"대":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"한":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"리":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"프":{"docs":{},"로":{"docs":{},"젝":{"docs":{},"트":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}},"되":{"docs":{},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"해":{"docs":{},"야":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"하":{"docs":{},"는":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"하":{"docs":{},"여":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}}},"계":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"없":{"docs":{},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"시":{"docs":{},"키":{"docs":{},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"의":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"점":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}}}}}},"해":{"docs":{},"선":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"심":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}},"이":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"찰":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231}}},"하":{"docs":{},"거":{"docs":{},"나":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}},"용":{"docs":{},"적":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}},"구":{"docs":{},"조":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.010399334442595673},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"가":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"와":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"화":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},"하":{"docs":{},"기":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.00530035335689046}},"에":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"체":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"적":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.005401234567901234}},"인":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"의":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},"는":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},"현":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"할":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"된":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"될":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"하":{"docs":{},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"더":{"docs":{},"라":{"docs":{},"도":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}},"여":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"고":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"해":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"야":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"놓":{"docs":{},"지":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"되":{"docs":{},"어":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}},"야":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"체":{"docs":{},"로":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}},"도":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"서":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}},"이":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"문":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.004282655246252677},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"일":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"으":{"docs":{},"로":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"성":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.00505902192242833},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"여":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.00946372239747634}}},",":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"할":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"은":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"된":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},".":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}}},"해":{"docs":{},"야":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"체":{"docs":{},"적":{"docs":{},"일":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"인":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}}},"으":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"\"":{"docs":{},"이":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}}},"축":{"docs":{},"하":{"docs":{},"거":{"docs":{},"나":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"별":{"docs":{},"돼":{"docs":{},"야":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"하":{"docs":{},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"할":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"은":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"분":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"하":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"여":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"된":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"에":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"애":{"docs":{},"받":{"docs":{},"지":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"기":{"docs":{},"능":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"지":{"docs":{},"만":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}},"도":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"으":{"docs":{},"로":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}},"과":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"록":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"도":{"docs":{},"록":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"할":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"반":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005250875145857643}},"한":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"해":{"docs":{},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"으":{"docs":{},"로":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"본":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":5},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004034065441506051},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.01646090534979424},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.014705882352941176},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005673758865248227},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0021413276231263384},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"(":{"docs":{},"위":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"인":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"(":{"docs":{},"위":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}},"값":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"과":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"은":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"를":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}},"이":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"만":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"존":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"술":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"하":{"docs":{},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807}},"데":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"지":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0021929824561403508},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"들":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"다":{"docs":{},"리":{"docs":{},"며":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"릴":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"려":{"docs":{},"서":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"억":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"하":{"docs":{},"나":{"docs":{},"요":{"docs":{},"?":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"세":{"docs":{},"요":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},".":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}},"해":{"docs":{},"야":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}},"한":{"docs":{},"다":{"docs":{},"면":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}},"대":{"docs":{},"해":{"docs":{},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"하":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"지":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"했":{"docs":{},"던":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"할":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"초":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.002831524303916942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"적":{"docs":{},"인":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"법":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"들":{"docs":{},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"명":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},"타":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"여":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}},"할":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"하":{"docs":{},"고":{"docs":{},",":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}}},"준":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},")":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"계":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},"회":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}},"꺼":{"docs":{},"이":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"나":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"타":{"docs":{},"내":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00823045267489712},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"고":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"기":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"날":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"납":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}}}}},"냅":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"t":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}}}}}}},"낼":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"나":{"docs":{},"기":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}},"열":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"된":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"되":{"docs":{},"어":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"는":{"docs":{},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}},"머":{"docs":{},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}}},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"중":{"docs":{},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"의":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"까":{"docs":{},"지":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"와":{"docs":{},"있":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}},"오":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"거":{"docs":{},"나":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"면":{"docs":{},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"온":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"뉩":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"옵":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"눌":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"아":{"docs":{},"가":{"docs":{},"서":{"docs":{},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"란":{"docs":{},"히":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"내":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"부":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"용":{"docs":{},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333}}},"은":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.00919732441471572},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.013824884792626729},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"의":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"물":{"docs":{},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},":":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0182370820668693}}}},"보":{"docs":{},"내":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"지":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},"거":{"docs":{},"나":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"냅":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.004180602006688963}},"소":{"docs":{},"스":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"낸":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}},"냄":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499}}},"낼":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"에":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0033034450212364322},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"만":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}},"가":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"려":{"docs":{},"야":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"장":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00823045267489712},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.010869565217391304},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.006417736289381563},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006611570247933884},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906}},"되":{"docs":{},"어":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"된":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"형":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"재":{"docs":{},"한":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"는":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"넣":{"docs":{},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546}}},"으":{"docs":{},"면":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"어":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"야":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"는":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"눌":{"docs":{},"러":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}},"도":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"단":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"일":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.002044989775051125},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"지":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"계":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"에":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"만":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"(":{"docs":{},"예":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}},"언":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"에":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"과":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"하":{"docs":{},"기":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}},"위":{"docs":{},"가":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"순":{"docs":{},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"화":{"docs":{},"할":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"히":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"하":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"점":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"들":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},"항":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}}},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"축":{"docs":{},"어":{"docs":{},"처":{"docs":{},"럼":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"당":{"docs":{},"신":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}},"이":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"의":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"장":{"docs":{},"은":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"연":{"docs":{},"히":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"더":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.005426356589147287},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0037437603993344427},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014790164540580515},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0028585040495474035},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.008321775312066574},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0051162790697674414}},"불":{"docs":{},"어":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"욱":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"해":{"docs":{},"보":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}},"질":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}}},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"도":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"구":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},"와":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":3.333333333333333}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}},"상":{"docs":{},"자":{"docs":{},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"들":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"만":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"뿐":{"docs":{},"만":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"움":{"docs":{},"말":{"docs":{},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}},"이":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"달":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"할":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}}},"와":{"docs":{},"줍":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}},"줄":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"입":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}},"됨":{"docs":{},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}},"우":{"docs":{},"미":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}},"메":{"docs":{},"인":{"docs":{},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"동":{"docs":{},"일":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"하":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"고":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"지":{"docs":{},"만":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"게":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"며":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"한":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"안":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}},"에":{"docs":{},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}},"적":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"인":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"이":{"docs":{},"고":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"으":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"작":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"므":{"docs":{},"로":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"며":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"하":{"docs":{},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"도":{"docs":{},"록":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"므":{"docs":{},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"지":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"만":{"docs":{},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"려":{"docs":{},"면":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"고":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"며":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"과":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"은":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"의":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"시":{"docs":{},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"형":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"지":{"docs":{},"만":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"의":{"docs":{},"어":{"docs":{},"이":{"docs":{},"기":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}},"될":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0021413276231263384},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968}},"만":{"docs":{},"한":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"것":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},"지":{"docs":{},"라":{"docs":{},"도":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"수":{"docs":{},"록":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"j":{"docs":{},"s":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}},"두":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.004815409309791332},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0031007751937984496},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.003585835948005379},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.006172839506172839},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0033349213911386373},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.005988023952095809},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.011494252873563218},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0033112582781456954},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"\"":{"docs":{},"십":{"docs":{},"억":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"번":{"docs":{},"째":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"개":{"docs":{},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}},"다":{"docs":{},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"세":{"docs":{},"요":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"려":{"docs":{},"워":{"docs":{},"하":{"docs":{},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"지":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"면":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"따":{"docs":{},"라":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"야":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"른":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"릅":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"르":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"면":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"를":{"docs":{},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"또":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"한":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.00505902192242833},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0028551034975017845},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.003943661971830986},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.00505902192242833},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.008293838862559242},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0028551034975017845},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0033112582781456954},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.01},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"t":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}}},"다":{"docs":{},"른":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"라":{"docs":{},"인":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}},"는":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"이":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"나":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"이":{"docs":{},"브":{"docs":{},"러":{"docs":{},"리":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.022058823529411766},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.016689847009735744},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004796163069544364},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.004867872044506259}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.006258692628650904},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}},"서":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0034770514603616135},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"가":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.005563282336578581}}},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"(":{"docs":{},"예":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}}}}}}}}},"라":{"docs":{},"고":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"들":{"docs":{},"은":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906}}},"의":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}}}}}}}},"벨":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"면":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"리":{"docs":{},"팩":{"docs":{},"토":{"docs":{},"링":{"docs":{},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"해":{"docs":{},"야":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"스":{"docs":{},"트":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"에":{"docs":{},"서":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"도":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"가":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"팅":{"docs":{},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"터":{"docs":{},"럴":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.006344171292624901},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00258827879460159},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"도":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0017844396859386152}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"어":{"docs":{},"야":{"docs":{},"만":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"의":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"과":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"액":{"docs":{},"트":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":3.333333333333333},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"에":{"docs":{},"서":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}},"선":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"와":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}}},"뷰":{"docs":{},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"턴":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"다":{"docs":{},"이":{"docs":{},"렉":{"docs":{},"트":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}},"눅":{"docs":{},"스":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}},"와":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"마":{"docs":{},"우":{"docs":{},"스":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"지":{"docs":{},"막":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}},"엔":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"찬":{"docs":{},"가":{"docs":{},"지":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"여":{"docs":{},"기":{"docs":{},"에":{"docs":{},"서":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},")":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"그":{"docs":{},"레":{"docs":{},"이":{"docs":{},"션":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":5.0011267605633805}}}}}}},"법":{"docs":{},"을":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"세":{"docs":{},"요":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.008}}},"!":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.008321775312066574}}}}},"주":{"docs":{},"치":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"치":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"침":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"찰":{"docs":{},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"커":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"자":{"docs":{},"막":{"docs":{},"으":{"docs":{},"로":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"들":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}}},"기":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}},"어":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}},"졌":{"docs":{},"으":{"docs":{},"며":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"야":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"낼":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"지":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"진":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"집":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"보":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}},"수":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"려":{"docs":{},"고":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"면":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"약":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0021929824561403508},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0031376064545047063},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0027731558513588465},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.006258692628650904},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.016},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"듭":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594}}}}}},"큼":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"드":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00823045267489712},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}}},"든":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}},"많":{"docs":{},"은":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.014705882352941176},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.004172461752433936},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}}},"거":{"docs":{},"나":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},"!":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"아":{"docs":{},"집":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}},"음":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"으":{"docs":{},"며":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"매":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"개":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.005924170616113744},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"변":{"docs":{},"수":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002962085308056872},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0046395431834403995},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"와":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"(":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"s":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}},"예":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0031376064545047063},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.004940014114326041},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.006172839506172839},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.009708737864077669},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}},"끼":{"docs":{},"리":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0021413276231263384},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"들":{"docs":{},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002689376961004034},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"든":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"라":{"docs":{},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"만":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"보":{"docs":{},"다":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"도":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"인":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"처":{"docs":{},"럼":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"니":{"docs":{},"저":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},")":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}},"우":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"겨":{"docs":{},"진":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"기":{"docs":{},"도":{"docs":{},"록":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"깁":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"칭":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617}},"되":{"docs":{},"는":{"docs":{},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"번":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"핑":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020336476243298205},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0023820867079561697},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"과":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"을":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"도":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"으":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"하":{"docs":{},"기":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"시":{"docs":{},"키":{"docs":{},"는":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}},"명":{"docs":{},"시":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"(":{"docs":{},"또":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"일":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"하":{"docs":{},"려":{"docs":{},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"해":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"되":{"docs":{},"어":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"지":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}},"할":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}},"령":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"문":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"과":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"줄":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"행":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"어":{"docs":{},"로":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}},"확":{"docs":{},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"하":{"docs":{},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"게":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"하":{"docs":{},"기":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"지":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"심":{"docs":{},"하":{"docs":{},"시":{"docs":{},"길":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"세":{"docs":{},"요":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},";":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},"해":{"docs":{},"야":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"목":{"docs":{},"적":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147}}}},"백":{"docs":{},"해":{"docs":{},"집":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"명":{"docs":{},"된":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"몇":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"몇":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"은":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"가":{"docs":{},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"모":{"docs":{},"두":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"보":{"docs":{},"다":{"docs":{},"는":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"가":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},"든":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0033802816901408453},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.01079136690647482},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0031007751937984496},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0021929824561403508},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002689376961004034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.006351446718419196},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.003965107057890563},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0022185246810870773},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0027266530334014998},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.00505902192242833},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.00946372239747634},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.014184397163120567},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.004180602006688963},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0069767441860465115}}},"듈":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Modules.html":{"ref":"pages/Modules.html","tf":10.013974096796183},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":5.025295109612141},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":5.019533111005241},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.005988023952095809},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0017844396859386152},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.011821974965229486},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.00919732441471572},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.006745362563237774},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.006669842782277275},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}},"이":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.008431703204047217},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968}},"라":{"docs":{},"고":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"나":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"부":{"docs":{},"터":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.00505902192242833},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0034083162917518746},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"도":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"과":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}},"당":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"도":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"들":{"docs":{},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"은":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00408997955010225},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.00505902192242833},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0034770514603616135}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0034083162917518746},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.00505902192242833},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"'":{"docs":{},"이":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}},"(":{"docs":{},"a":{"docs":{},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887}}}}}}}}}},"만":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"임":{"docs":{},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},")":{"docs":{},"의":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"군":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"형":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906}}},"인":{"docs":{},"지":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"델":{"docs":{},"링":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"하":{"docs":{},"는":{"docs":{},"데":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"은":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"에":{"docs":{},"서":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}},"르":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"거":{"docs":{},"나":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"아":{"docs":{},"서":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"방":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"하":{"docs":{},"려":{"docs":{},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"릅":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}},"습":{"docs":{},"을":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"이":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"드":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881}}},"들":{"docs":{},"은":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"와":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}},"로":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"호":{"docs":{},"해":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"목":{"docs":{},"록":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"과":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.014492753623188406},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"만":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"으":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}},"은":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"처":{"docs":{},"럼":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"이":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"가":{"docs":{},"능":{"docs":{},"한":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"의":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"보":{"docs":{},"기":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}},"적":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"을":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"은":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"차":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"못":{"docs":{},"한":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"다":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}},"하":{"docs":{},"게":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"도":{"docs":{},"록":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"할":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},".":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}},"바":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"꿀":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"수":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}},"꾸":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"게":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"고":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"꿔":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"줍":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},"깥":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}},"에":{"docs":{},"서":{"docs":{},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"인":{"docs":{},"딩":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"되":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"에":{"docs":{},"서":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}},"르":{"docs":{},"게":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"랍":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"람":{"docs":{},"직":{"docs":{},"하":{"docs":{},"지":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196}}},"진":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"벨":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"꿉":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"뀌":{"docs":{},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"뀝":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"닐":{"docs":{},"라":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"이":{"docs":{},"트":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"발":{"docs":{},"생":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"한":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"다":{"docs":{},"는":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"하":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"며":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"면":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"도":{"docs":{},"록":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"시":{"docs":{},"키":{"docs":{},"거":{"docs":{},"나":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"지":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"킵":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"킬":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"함":{"docs":{},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"전":{"docs":{},"시":{"docs":{},"켜":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}},"견":{"docs":{},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"하":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"되":{"docs":{},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"췌":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"배":{"docs":{},"열":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0031007751937984496},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0024958402662229617},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.011185682326621925},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"과":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"처":{"docs":{},"럼":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"서":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"은":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"인":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"의":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"이":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"나":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"치":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"우":{"docs":{},"고":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"진":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"웠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"울":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"워":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"보":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}}},"포":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},"하":{"docs":{},"기":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"는":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"려":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}},"되":{"docs":{},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}},"할":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"다":{"docs":{},"음":{"docs":{},"과":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}},"버":{"docs":{},"튼":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627}}}}},"그":{"docs":{},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"이":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"리":{"docs":{},"게":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"전":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"의":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"에":{"docs":{},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"부":{"docs":{},"터":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"과":{"docs":{},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"은":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},":":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"립":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}},"변":{"docs":{},"경":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"해":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}},"야":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"하":{"docs":{},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"여":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"지":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"면":{"docs":{},",":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"는":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"되":{"docs":{},"지":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"든":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}},"될":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"할":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}},"이":{"docs":{},"제":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"편":{"docs":{},"리":{"docs":{},"하":{"docs":{},"게":{"docs":{},"도":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},")":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"된":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"사":{"docs":{},"항":{"docs":{},"을":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"에":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"은":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"을":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}}},"의":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"이":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"수":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":5.007071547420965},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004146919431279621},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.007067137809187279},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.006239600665557404},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"가":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0024958402662229617},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"서":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"들":{"docs":{},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"도":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},"나":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}},"환":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}},"려":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"할":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"(":{"docs":{},"형":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},")":{"docs":{},"과":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"해":{"docs":{},"봅":{"docs":{},"시":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"되":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"어":{"docs":{},"야":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"도":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"이":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"하":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"화":{"docs":{},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"가":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"에":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}},"형":{"docs":{},"시":{"docs":{},"킵":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"하":{"docs":{},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"한":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"된":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"동":{"docs":{},"성":{"docs":{},"이":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"보":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.004815409309791332},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"이":{"docs":{},"것":{"docs":{},"은":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":2.5},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"려":{"docs":{},"면":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}},"게":{"docs":{},"해":{"docs":{},"야":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"일":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"러":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"냅":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"통":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"의":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"다":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"하":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"며":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.005852842809364548}},"상":{"docs":{},"속":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"할":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"된":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"단":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"면":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"았":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"다":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"이":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"지":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"만":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"여":{"docs":{},"줍":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}},"주":{"docs":{},"기":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"지":{"docs":{},"만":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"고":{"docs":{},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"줌":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"줄":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"장":{"docs":{},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"되":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"하":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"데":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"신":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"강":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323}},"하":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"지":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"과":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"된":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"에":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"을":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"할":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}},"기":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"수":{"docs":{},"가":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"간":{"docs":{},"하":{"docs":{},"여":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"도":{"docs":{},"록":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}},"존":{"docs":{},"하":{"docs":{},"며":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"될":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"실":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"복":{"docs":{},"사":{"docs":{},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}},"여":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"거":{"docs":{},"나":{"docs":{},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"지":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"본":{"docs":{},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"되":{"docs":{},"어":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}},"잡":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"한":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"하":{"docs":{},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"해":{"docs":{},"집":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}},"볼":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.004815409309791332},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00427715996578272},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.005563282336578581}},"까":{"docs":{},"요":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"분":{"docs":{},"석":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"하":{"docs":{},"기":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},"리":{"docs":{},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"서":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"되":{"docs":{},"어":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"된":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"명":{"docs":{},"히":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"들":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"이":{"docs":{},"라":{"docs":{},"면":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"해":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.004159733777038269}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}},"된":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"될":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"와":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"처":{"docs":{},"럼":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}},"에":{"docs":{},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}},"산":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386}},"되":{"docs":{},"었":{"docs":{},"는":{"docs":{},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"할":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}},"하":{"docs":{},"는":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}},"해":{"docs":{},"야":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}},"붙":{"docs":{},"여":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"야":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"줄":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"집":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}},"이":{"docs":{},"겠":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"더":{"docs":{},"라":{"docs":{},"도":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"혀":{"docs":{},"집":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}},"히":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"반":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"였":{"docs":{},"으":{"docs":{},"니":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"임":{"docs":{},"으":{"docs":{},"로":{"docs":{},"써":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"어":{"docs":{},"야":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}},"브":{"docs":{},"라":{"docs":{},"우":{"docs":{},"저":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"에":{"docs":{},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}},"가":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"와":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"레":{"docs":{},"이":{"docs":{},"크":{"docs":{},"포":{"docs":{},"인":{"docs":{},"트":{"docs":{},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}},"랜":{"docs":{},"치":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"의":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}},"뿐":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}},"만":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}},"사":{"docs":{},"용":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.006934812760055479},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.015197568389057751},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}},"되":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"지":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"지":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"며":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"거":{"docs":{},"나":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"도":{"docs":{},"록":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"자":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"로":{"docs":{},"부":{"docs":{},"터":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"도":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"들":{"docs":{},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"에":{"docs":{},"게":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}},"의":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},"에":{"docs":{},"게":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"는":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"겐":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.003943661971830986},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.00505902192242833},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0023820867079561697},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"데":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"여":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.004815409309791332},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0033802816901408453},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.005995203836930456},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.002831524303916942},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.004430811179277437},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029171528588098016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004739336492890996},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0039257673090649535},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.005518763796909493},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0075},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"기":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.002044989775051125},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"에":{"docs":{},"서":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"\"":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"겠":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}},"면":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}},"도":{"docs":{},"록":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.018433179723502304}}}},"려":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"면":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0031007751937984496},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.011095700416088766},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"만":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"셔":{"docs":{},"야":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"세":{"docs":{},"요":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.012367491166077738},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.004172461752433936},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"느":{"docs":{},"냐":{"docs":{},"에":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}},"던":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"거":{"docs":{},"나":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"길":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"할":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.003875968992248062},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0021929824561403508},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.002831524303916942},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.004940014114326041},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.003965107057890563},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.002958032908116103},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0054533060668029995},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.006128702757916241},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.01011804384485666},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.006417736289381563},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.006516587677725118},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0032119914346895075},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.004867872044506259},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.01694915254237288},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.004186046511627907}},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"\"":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"기":{"docs":{},"본":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"해":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0021413276231263384},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}},"서":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"야":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"봤":{"docs":{},"다":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"보":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"도":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"본":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"했":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"다":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"던":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"고":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"한":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}},"다":{"docs":{},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"고":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"지":{"docs":{},"원":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"함":{"docs":{},"으":{"docs":{},"로":{"docs":{},"써":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"될":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"수":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"법":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"과":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"은":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"된":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"다":{"docs":{},"면":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"됨":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"으":{"docs":{},"로":{"docs":{},"부":{"docs":{},"터":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"은":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"라":{"docs":{},"지":{"docs":{},"려":{"docs":{},"면":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"항":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"은":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"이":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"므":{"docs":{},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"라":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"을":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"임":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"에":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"는":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"서":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"이":{"docs":{},"클":{"docs":{},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"즈":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"드":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"람":{"docs":{},"들":{"docs":{},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"에":{"docs":{},"게":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}},"이":{"docs":{},"라":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}},"실":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}},"만":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"상":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"을":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}},"례":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"양":{"docs":{},"에":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"을":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"새":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922}},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"운":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.005035246727089627},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0029118136439267887},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0033034450212364322},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0022185246810870773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.004867872044506259},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.004186046511627907}}},"고":{"docs":{},"침":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"생":{"docs":{},"성":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"되":{"docs":{},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}}},"는":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"된":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705}}},"자":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.006134969325153374},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00823045267489712},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004146919431279621},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0028551034975017845},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"와":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}}}},"이":{"docs":{},"고":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"기":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"위":{"docs":{},"해":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"려":{"docs":{},"고":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"여":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"였":{"docs":{},"고":{"docs":{},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"거":{"docs":{},"나":{"docs":{},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942}}},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"할":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"될":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"함":{"docs":{},"으":{"docs":{},"로":{"docs":{},"써":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"기":{"docs":{},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"한":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}},"각":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"여":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"해":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}},"야":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}},"볼":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"보":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},";":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"봅":{"docs":{},"시":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}},"봐":{"docs":{},"야":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"할":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"태":{"docs":{},"계":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"긴":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"깁":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"략":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}},"할":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},"될":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"서":{"docs":{},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"버":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"명":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"브":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"타":{"docs":{},"이":{"docs":{},"핑":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"클":{"docs":{},"래":{"docs":{},"싱":{"docs":{},"을":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"술":{"docs":{},"어":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"인":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"수":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"비":{"docs":{},"스":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"에":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"설":{"docs":{},"치":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0182370820668693},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}},"하":{"docs":{},"기":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},"지":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},".":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"t":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"u":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"처":{"docs":{},"럼":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}},"거":{"docs":{},"나":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"고":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"며":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"되":{"docs":{},"었":{"docs":{},"으":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"어":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"할":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"이":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"했":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}},"된":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"가":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"한":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"정":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.006042296072507553},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.011347517730496455},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"은":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"이":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"하":{"docs":{},"여":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"며":{"docs":{},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}},"지":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}},"되":{"docs":{},"어":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"었":{"docs":{},"다":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"기":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"지":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"면":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"할":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},"될":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"에":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"했":{"docs":{},"기":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"다":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"된":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"한":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"시":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"명":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"해":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"되":{"docs":{},"어":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}}},"하":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"므":{"docs":{},"로":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"려":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}},"고":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"기":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.00530035335689046}}}},"했":{"docs":{},"던":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"된":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"한":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}},"다":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"대":{"docs":{},"로":{"docs":{},")":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}}}}},"을":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}},"자":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498}},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}},"가":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"로":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}},"계":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"되":{"docs":{},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}},"섹":{"docs":{},"션":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"서":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.01838235294117647}}},"들":{"docs":{},"로":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}}},"시":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"작":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},"!":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}}},"해":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"야":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"하":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}},"기":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"려":{"docs":{},"면":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"여":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"고":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"합":{"docs":{},"시":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},";":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"으":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"될":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"점":{"docs":{},"을":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}},"간":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"이":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}},"스":{"docs":{},"템":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"기":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"보":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"은":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147}}},"의":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},"인":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"과":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"점":{"docs":{},"에":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"서":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"나":{"docs":{},"리":{"docs":{},"오":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}},"에":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"가":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}},"키":{"docs":{},"겠":{"docs":{},"지":{"docs":{},"만":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}},"그":{"docs":{},"니":{"docs":{},"처":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"와":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"인":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"라":{"docs":{},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"(":{"docs":{},"있":{"docs":{},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},")":{"docs":{},"을":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"도":{"docs":{},"하":{"docs":{},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"해":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}},"킬":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"마":{"docs":{},"다":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"험":{"docs":{},"용":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}},"퀀":{"docs":{},"스":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"행":{"docs":{},"되":{"docs":{},"며":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"식":{"docs":{},"별":{"docs":{},"자":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}},"이":{"docs":{},"기":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"에":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"하":{"docs":{},"기":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.004172461752433936}}},"고":{"docs":{},",":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},"는":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968}}}},"한":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"되":{"docs":{},"지":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"할":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}},"으":{"docs":{},"로":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"은":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}},"실":{"docs":{},"행":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}},"하":{"docs":{},"기":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"세":{"docs":{},"요":{"docs":{},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"도":{"docs":{},"록":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"면":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"며":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"게":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"려":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"여":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"해":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"보":{"docs":{},"세":{"docs":{},"요":{"docs":{},"!":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"되":{"docs":{},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}},"어":{"docs":{},"야":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"면":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"기":{"docs":{},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"될":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"한":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"(":{"docs":{},"다":{"docs":{},"른":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}},"수":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"들":{"docs":{},"은":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},"을":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}},"험":{"docs":{},"적":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"인":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"단":{"docs":{},"계":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"제":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"론":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"패":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"함":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"할":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"용":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"시":{"docs":{},"했":{"docs":{},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"심":{"docs":{},"벌":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00823045267489712}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"들":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}},"은":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}},"이":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}},"은":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.01646090534979424},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"에":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"와":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"의":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"지":{"docs":{},"어":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"각":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"볼":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":10}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"층":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"아":{"docs":{},"래":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.003965107057890563}}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"서":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"로":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"직":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},"닌":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.004234297812279464},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},")":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"닙":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"중":{"docs":{},"요":{"docs":{},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"님":{"docs":{},"을":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"무":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"렇":{"docs":{},"게":{"docs":{},"나":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"것":{"docs":{},"도":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"에":{"docs":{},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"거":{"docs":{},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"런":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"도":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"니":{"docs":{},"라":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"면":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"기":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"고":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"마":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"도":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"예":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"랫":{"docs":{},"줄":{"docs":{},"은":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"주":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"이":{"docs":{},"디":{"docs":{},"어":{"docs":{},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"닐":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}},"안":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":2.5},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"전":{"docs":{},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"성":{"docs":{},"과":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}},"하":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"게":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"한":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}}},"된":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0033112582781456954}}},"쪽":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"내":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"되":{"docs":{},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"정":{"docs":{},"될":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"적":{"docs":{},"인":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"않":{"docs":{},"았":{"docs":{},"다":{"docs":{},"면":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"기":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"는":{"docs":{},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},".":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}},"으":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}}}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}},"때":{"docs":{},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}},"도":{"docs":{},"록":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}}},"으":{"docs":{},"면":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"므":{"docs":{},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}},"며":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}}},"은":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00427715996578272},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0032119914346895075},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"데":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},")":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.005547850208044383},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"다":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"고":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}},")":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"에":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"다":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0425}},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0029118136439267887},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0021929824561403508},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014790164540580515},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0027266530334014998},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029171528588098016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005673758865248227},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.011705685618729096},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},")":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}},"아":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"도":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"음":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"에":{"docs":{},"서":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"거":{"docs":{},"나":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"지":{"docs":{},"만":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"알":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"려":{"docs":{},"줄":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"줘":{"docs":{},"야":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"줍":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"주":{"docs":{},"어":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},"길":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"진":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.012345679012345678},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},")":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"져":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"지":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"아":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"야":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"볼":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"\"":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"낼":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"두":{"docs":{},"면":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}},"차":{"docs":{},"리":{"docs":{},"겠":{"docs":{},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}},"보":{"docs":{},"기":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"(":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}}}}}}}}},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}}},"채":{"docs":{},"셨":{"docs":{},"나":{"docs":{},"요":{"docs":{},"?":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},"내":{"docs":{},"기":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"림":{"docs":{},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}},"리":{"docs":{},"즘":{"docs":{},"에":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"은":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"리":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"립":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"다":{"docs":{},"시":{"docs":{},"피":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"맞":{"docs":{},"게":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"은":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}},"기":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"릴":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"애":{"docs":{},"플":{"docs":{},"리":{"docs":{},"케":{"docs":{},"이":{"docs":{},"션":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"서":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"은":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887}}},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}},"매":{"docs":{},"하":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"앱":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"에":{"docs":{},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"이":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"없":{"docs":{},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"다":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}},"면":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.003875968992248062},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0037437603993344427},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002631578947368421},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0056457304163726185},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020336476243298205},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0035545023696682463},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0021413276231263384},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0051162790697674414}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}}},"!":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},")":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"으":{"docs":{},"며":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"면":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"므":{"docs":{},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"음":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"더":{"docs":{},"라":{"docs":{},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"어":{"docs":{},"야":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"서":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"도":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"지":{"docs":{},"만":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}},"기":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"기":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"거":{"docs":{},"나":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"도":{"docs":{},"록":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}},"디":{"docs":{},"터":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"에":{"docs":{},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}}},"러":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"!":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"를":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"여":{"docs":{},"기":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"도":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"서":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"선":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"엔":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"전":{"docs":{},"히":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"겨":{"docs":{},"지":{"docs":{},"고":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"며":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},"러":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0040858018386108275},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.00505902192242833},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"분":{"docs":{},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"을":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}},"개":{"docs":{},"의":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"태":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"부":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"열":{"docs":{},"거":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"나":{"docs":{},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}},"형":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":10.032513877874703},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0033112582781456954},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"과":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"에":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}},"서":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504}}}},"으":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"은":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.011102299762093577},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"을":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.006344171292624901},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"의":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.008723235527359239}}},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"처":{"docs":{},"럼":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"하":{"docs":{},"고":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"어":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"보":{"docs":{},"세":{"docs":{},"요":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"줄":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"린":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"예":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"상":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"대":{"docs":{},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}},"치":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"되":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"해":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"하":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"시":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.008620689655172414}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"와":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}},"제":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.015772870662460567},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},"서":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0033112582781456954}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"처":{"docs":{},"럼":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"이":{"docs":{},"며":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695}}},"와":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"들":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"에":{"docs":{},"서":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"을":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"만":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.005426356589147287},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002631578947368421},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.011185682326621925},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00258827879460159},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0023858214042263124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.003811338732729871},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0039257673090649535},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.006258692628650904},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.006622516556291391},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005673758865248227},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"술":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"측":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"이":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"는":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"외":{"docs":{},"를":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},")":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"가":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}},"사":{"docs":{},"항":{"docs":{},"은":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"전":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},":":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231}}}}}},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}},"약":{"docs":{},"어":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}},"와":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},".":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"는":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"올":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"려":{"docs":{},"놓":{"docs":{},"고":{"docs":{},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}},"으":{"docs":{},"면":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}},"바":{"docs":{},"른":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},"르":{"docs":{},"게":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}}},"름":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}}},"리":{"docs":{},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"라":{"docs":{},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"오":{"docs":{},"게":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},"옵":{"docs":{},"션":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":5.003344481605351},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":3.343333333333333},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"들":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},".":{"docs":{},".":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"j":{"docs":{},"s":{"docs":{},",":{"docs":{},"a":{"docs":{},"m":{"docs":{},"d":{"docs":{},",":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}}}}}}}}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0050704225352112674},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005673758865248227},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"에":{"docs":{},"서":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"과":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"이":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"나":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"의":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"완":{"docs":{},"료":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}},"되":{"docs":{},"었":{"docs":{},"음":{"docs":{},"에":{"docs":{},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"면":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}},"성":{"docs":{},"과":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"전":{"docs":{},"히":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},"함":{"docs":{},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"벽":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"화":{"docs":{},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"우":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"리":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"가":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546}}},"를":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}},"연":{"docs":{},"한":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"선":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}},"순":{"docs":{},"위":{"docs":{},"를":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"으":{"docs":{},"로":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"시":{"docs":{},"한":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"웹":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.004815409309791332},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}},"사":{"docs":{},"이":{"docs":{},"트":{"docs":{},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}},"팩":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":3.333333333333333}}}},"위":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"한":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}}},"해":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0050704225352112674},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0029118136439267887},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.002831524303916942},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014790164540580515},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0023858214042263124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.006128702757916241},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.011029411764705883},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.014134275618374558},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0032558139534883722}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"만":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"선":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"치":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.005518763796909493},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},"한":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"(":{"docs":{},"즉":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"하":{"docs":{},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"게":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"할":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},"가":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029171528588098016},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"와":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"처":{"docs":{},"럼":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"험":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}},"성":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}},"과":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.007150153217568948},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.008168028004667444},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"함":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}},"젯":{"docs":{},"의":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}}},")":{"docs":{},"와":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"키":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"유":{"docs":{},"의":{"docs":{},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},";":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"해":{"docs":{},"주":{"docs":{},"세":{"docs":{},"요":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}},"야":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"미":{"docs":{},"하":{"docs":{},"고":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"한":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},":":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"할":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"사":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"만":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"게":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}},"연":{"docs":{},"한":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"함":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}},"용":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"(":{"docs":{},"예":{"docs":{},",":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"하":{"docs":{},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"만":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"려":{"docs":{},"면":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"다":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"고":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"한":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"지":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"하":{"docs":{},"려":{"docs":{},"면":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"거":{"docs":{},"나":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"기":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"만":{"docs":{},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"고":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"한":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"형":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"은":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"에":{"docs":{},"서":{"docs":{},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"으":{"docs":{},"로":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}},"일":{"docs":{},"한":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00823045267489712},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"하":{"docs":{},"기":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"다":{"docs":{},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"니":{"docs":{},"언":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00517655758920318},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"으":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"발":{"docs":{},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"하":{"docs":{},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}},"효":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}},"한":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"하":{"docs":{},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"성":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"래":{"docs":{},"된":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"추":{"docs":{},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"하":{"docs":{},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"할":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"저":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"들":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"로":{"docs":{},"서":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"명":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"한":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906}}}},"틸":{"docs":{},"리":{"docs":{},"티":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":5.001051524710831}},"는":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.004206098843322818}}},"들":{"docs":{},"은":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"를":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}},"무":{"docs":{},"를":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"인":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"수":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.004940014114326041},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0038580246913580245},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"와":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498}}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"는":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"만":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"터":{"docs":{},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":10.003070175438596},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"가":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0021929824561403508},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.003947368421052632},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0035285815102328866},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}},"나":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.004824561403508772},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"들":{"docs":{},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"이":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}},"써":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"부":{"docs":{},"터":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"서":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}},"처":{"docs":{},"럼":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},")":{"docs":{},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}}},"라":{"docs":{},"인":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"되":{"docs":{},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"으":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"쇄":{"docs":{},"해":{"docs":{},"야":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"스":{"docs":{},"턴":{"docs":{},"스":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0033034450212364322},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0035545023696682463},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0037753657385559227},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"가":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"화":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"될":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"하":{"docs":{},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"할":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"에":{"docs":{},"서":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"해":{"docs":{},"서":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"로":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}},"써":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"만":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"도":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"마":{"docs":{},"다":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"식":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"지":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}},"되":{"docs":{},"는":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"해":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"덱":{"docs":{},"스":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0043859649122807015},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.003512664078387872},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"들":{"docs":{},"에":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}},"를":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}},"싱":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"하":{"docs":{},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"서":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}}},"블":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}},"에":{"docs":{},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"지":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"되":{"docs":{},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"데":{"docs":{},"스":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"자":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},"들":{"docs":{},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}},"용":{"docs":{},"된":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},")":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"사":{"docs":{},"이":{"docs":{},"트":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"말":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"을":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}},"의":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"이":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"기":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}},"일":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"반":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"적":{"docs":{},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"며":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"기":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"고":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"어":{"docs":{},"서":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"인":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"는":{"docs":{},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"임":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"부":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"로":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"써":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"이":{"docs":{},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"인":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"가":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"련":{"docs":{},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"시":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}},"더":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"며":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"치":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.012345679012345678},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"도":{"docs":{},"록":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"게":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"기":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"해":{"docs":{},"야":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"할":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"컫":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"단":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"으":{"docs":{},"키":{"docs":{},"거":{"docs":{},"나":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"겠":{"docs":{},"군":{"docs":{},"요":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}}},"킵":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881}}}}}},"킨":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"킬":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"관":{"docs":{},"성":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"이":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"된":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"찍":{"docs":{},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"종":{"docs":{},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"회":{"docs":{},"성":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"인":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"어":{"docs":{},"나":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"지":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},"대":{"docs":{},"일":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887}}}},"들":{"docs":{},"이":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"수":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"입":{"docs":{},"력":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}},"세":{"docs":{},"요":{"docs":{},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"면":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"기":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"할":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}},"해":{"docs":{},"보":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},"받":{"docs":{},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"을":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"과":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"에":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0033112582781456954},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"'":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}},"장":{"docs":{},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"자":{"docs":{},"동":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"주":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}}},"세":{"docs":{},"한":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.008361204013377926},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0243161094224924},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.013824884792626729},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}}},"히":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}},"체":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"가":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"적":{"docs":{},"인":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"와":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"리":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"료":{"docs":{},"형":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}}},"신":{"docs":{},"들":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"만":{"docs":{},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"에":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"식":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004084014002333722}},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"게":{"docs":{},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"은":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"연":{"docs":{},"스":{"docs":{},"러":{"docs":{},"운":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"럽":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}}},"유":{"docs":{},"롭":{"docs":{},"게":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"기":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"작":{"docs":{},"동":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"지":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"여":{"docs":{},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}},"지":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"만":{"docs":{},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"거":{"docs":{},"나":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"시":{"docs":{},"키":{"docs":{},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"한":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"할":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}},"성":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},":":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}},"게":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.011029411764705883},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"지":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"려":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"자":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"든":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"여":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"거":{"docs":{},"나":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}},"면":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"할":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},":":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"해":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}},"보":{"docs":{},"세":{"docs":{},"요":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"야":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.005547850208044383},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"했":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"다":{"docs":{},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"던":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"고":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"으":{"docs":{},"므":{"docs":{},"로":{"docs":{},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}},"된":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},"다":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"되":{"docs":{},"고":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"었":{"docs":{},"다":{"docs":{},"고":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"면":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}},"어":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"자":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"에":{"docs":{},"게":{"docs":{},"는":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},"일":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"될":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"에":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},"의":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},"업":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"이":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"할":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"하":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"기":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"은":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"은":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},"따":{"docs":{},"옴":{"docs":{},"표":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"용":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"재":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"실":{"docs":{},"행":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}},"구":{"docs":{},"성":{"docs":{},"하":{"docs":{},"지":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}},"선":{"docs":{},"언":{"docs":{},"과":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"할":{"docs":{},"당":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"사":{"docs":{},"용":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.007067137809187279}},"성":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"할":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"하":{"docs":{},"기":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"정":{"docs":{},"의":{"docs":{},"할":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"하":{"docs":{},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"순":{"docs":{},"환":{"docs":{},"성":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}},"귀":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"인":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"검":{"docs":{},"사":{"docs":{},"/":{"docs":{},"재":{"docs":{},"빌":{"docs":{},"드":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"하":{"docs":{},"지":{"docs":{},"않":{"docs":{},"고":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}},"빌":{"docs":{},"드":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"전":{"docs":{},"달":{"docs":{},"하":{"docs":{},"도":{"docs":{},"록":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"든":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"고":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}},"할":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}},"된":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"한":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"다":{"docs":{},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"해":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"야":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"될":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"이":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"됨":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"했":{"docs":{},"기":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"되":{"docs":{},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"/":{"docs":{},"중":{"docs":{},"복":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}},"송":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"용":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},")":{"docs":{},"이":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"으":{"docs":{},"로":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}}}}}}},"으":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"이":{"docs":{},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"었":{"docs":{},"다":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"라":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}},"형":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"환":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"려":{"docs":{},"는":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"할":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"역":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.003067484662576687},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.024339360222531293},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.01060070671378092},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"으":{"docs":{},"로":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"도":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"에":{"docs":{},"서":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"의":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"통":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"인":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}},"체":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"에":{"docs":{},"서":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}},"개":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}},"보":{"docs":{},"다":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"처":{"docs":{},"럼":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"하":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"도":{"docs":{},"록":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}},"면":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"까":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"혀":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"부":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"면":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"략":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017}},"들":{"docs":{},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"으":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"에":{"docs":{},"서":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"제":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},",":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"처":{"docs":{},"리":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135}},"를":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},"자":{"docs":{},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"절":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"대":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"로":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"적":{"docs":{},"인":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"점":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"차":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"진":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"만":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"프":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"했":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"으":{"docs":{},"로":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"정":{"docs":{},"보":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"도":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"만":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"에":{"docs":{},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},")":{"docs":{},"에":{"docs":{},"도":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"가":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"와":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"로":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}},"로":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}},"데":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"엔":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"면":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"되":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"면":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},",":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"어":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}},"했":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"된":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922}}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231}}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002962085308056872},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"한":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"만":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"해":{"docs":{},"야":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"들":{"docs":{},"이":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"의":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"에":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"적":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002962085308056872},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}},"인":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"리":{"docs":{},"하":{"docs":{},"도":{"docs":{},"록":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"확":{"docs":{},"히":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"하":{"docs":{},"게":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}},"함":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}},"한":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"할":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"해":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"진":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"줄":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"지":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"교":{"docs":{},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"로":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"의":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}},"말":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"로":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"답":{"docs":{},"은":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"하":{"docs":{},"게":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}},"방":{"docs":{},"향":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"규":{"docs":{},"식":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.01646090534979424}},"과":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00823045267489712}}},"을":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}},"렬":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}},"하":{"docs":{},"기":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},"당":{"docs":{},"한":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"책":{"docs":{},"이":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"제":{"docs":{},"거":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"해":{"docs":{},"보":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"면":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"거":{"docs":{},"나":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"된":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"되":{"docs":{},"어":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"며":{"docs":{},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"므":{"docs":{},"로":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"한":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"공":{"docs":{},"된":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"며":{"docs":{},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"고":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"일":{"docs":{},"단":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"\"":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"해":{"docs":{},"줍":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"주":{"docs":{},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"야":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}},"했":{"docs":{},"는":{"docs":{},"지":{"docs":{},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"할":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"되":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"지":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"만":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}},"외":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},")":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"면":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"곤":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"기":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"된":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"되":{"docs":{},"었":{"docs":{},"는":{"docs":{},"지":{"docs":{},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"해":{"docs":{},"야":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"한":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"될":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"일":{"docs":{},"반":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"j":{"docs":{},"s":{"docs":{},"가":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}}},"네":{"docs":{},"릭":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":10.023288637967537},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0038580246913580245},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0017844396859386152},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"에":{"docs":{},"서":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"을":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732}}},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"이":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"라":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"므":{"docs":{},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}},"레":{"docs":{},"이":{"docs":{},"터":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":5}}}}}},"대":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"한":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}},"점":{"docs":{},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"되":{"docs":{},"어":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"된":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"하":{"docs":{},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"지":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"할":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"을":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"약":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"사":{"docs":{},"항":{"docs":{},"을":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"조":{"docs":{},"건":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"에":{"docs":{},"서":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"을":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"이":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}},"어":{"docs":{},"할":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"하":{"docs":{},"기":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"안":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"이":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"며":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"의":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"출":{"docs":{},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}},"존":{"docs":{},"재":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"하":{"docs":{},"기":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}},"더":{"docs":{},"라":{"docs":{},"도":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"거":{"docs":{},"나":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"므":{"docs":{},"로":{"docs":{},",":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"이":{"docs":{},"러":{"docs":{},"한":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}}}},"할":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"해":{"docs":{},"도":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"한":{"docs":{},"다":{"docs":{},"고":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"원":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"과":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"이":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"하":{"docs":{},"지":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"며":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"고":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"기":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"되":{"docs":{},"지":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.045}}},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"해":{"docs":{},"야":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}},"보":{"docs":{},"다":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"은":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"할":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"향":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"적":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"시":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942}},"또":{"docs":{},"한":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"문":{"docs":{},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"어":{"docs":{},"는":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.019834710743801654}}},"로":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"를":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006611570247933884}}},"와":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}},"자":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":3.333333333333333}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"정":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881}},"되":{"docs":{},"지":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"어":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}},"야":{"docs":{},"함":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"면":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.005852842809364548},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"한":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"하":{"docs":{},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"만":{"docs":{},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"데":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617}}},"기":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"려":{"docs":{},"고":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"면":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"여":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004084014002333722},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0046395431834403995},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"자":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"나":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"와":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"로":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"해":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"야":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"된":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005673758865248227},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},"함":{"docs":{},"으":{"docs":{},"로":{"docs":{},"써":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"했":{"docs":{},"다":{"docs":{},"면":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0033349213911386373}}}}}},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}},"금":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"부":{"docs":{},"터":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"은":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"까":{"docs":{},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"루":{"docs":{},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"역":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"화":{"docs":{},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"어":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"점":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"부":{"docs":{},"터":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"난":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"연":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"될":{"docs":{},"지":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"우":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"지":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"침":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}},"을":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"식":{"docs":{},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"이":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588}}}},"워":{"docs":{},"집":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"첫":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"째":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"번":{"docs":{},"째":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}},"추":{"docs":{},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.006042296072507553},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702}},"그":{"docs":{},"런":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"여":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"자":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}},"길":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"면":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"게":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"거":{"docs":{},"나":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"지":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"할":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.005518763796909493},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}},"n":{"docs":{},"p":{"docs":{},"m":{"docs":{},"과":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},";":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}},"해":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"야":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"되":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"기":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"어":{"docs":{},"야":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"어":{"docs":{},"야":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},"적":{"docs":{},"인":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"으":{"docs":{},"로":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"한":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}},"다":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"된":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"될":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"론":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":5},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"되":{"docs":{},"기":{"docs":{},"도":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}},"길":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"는":{"docs":{},"지":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}},"지":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}},"된":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"하":{"docs":{},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"는":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"려":{"docs":{},"면":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}},"은":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"을":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695}}},"이":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"만":{"docs":{},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"해":{"docs":{},"볼":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"상":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.006134969325153374},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"화":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"으":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"적":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"하":{"docs":{},"고":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"출":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}},"하":{"docs":{},"여":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"할":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"천":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}},"축":{"docs":{},"약":{"docs":{},"형":{"docs":{},"일":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}}}}}},"커":{"docs":{},"맨":{"docs":{},"드":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}},"서":{"docs":{},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}},"버":{"docs":{},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"지":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}},"뮤":{"docs":{},"니":{"docs":{},"티":{"docs":{},"에":{"docs":{},"서":{"docs":{},"도":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}}},"스":{"docs":{},"텀":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"컴":{"docs":{},"파":{"docs":{},"일":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"러":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00851063829787234},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":5.002508361204013},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":3.348333333333333},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"게":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0033349213911386373},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006611570247933884}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"따":{"docs":{},"라":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.006669842782277275},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0017844396859386152},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617}}},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.005717008099094807},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"의":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"/":{"docs":{},"언":{"docs":{},"어":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"하":{"docs":{},"기":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"면":{"docs":{},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}},"도":{"docs":{},"록":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"여":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"고":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{},"이":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"이":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}}},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}},"할":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"된":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"서":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"의":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"포":{"docs":{},"넌":{"docs":{},"트":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004667444574095682}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029171528588098016}}},"를":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}},"나":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"의":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841}}},"(":{"docs":{},"s":{"docs":{},"f":{"docs":{},"c":{"docs":{},")":{"docs":{},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"서":{"docs":{},"도":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"퓨":{"docs":{},"터":{"docs":{},"에":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}},"코":{"docs":{},"드":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.014134275618374558},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}},"가":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},",":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008025682182985553},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.008056394763343404},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.006284367635506678},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.008431703204047217},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"는":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}},"와":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"처":{"docs":{},"럼":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"베":{"docs":{},"이":{"docs":{},"스":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"나":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"들":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"어":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"딩":{"docs":{},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"크":{"docs":{},"게":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"기":{"docs":{},"가":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0021929824561403508},"pages/Classes.html":{"ref":"pages/Classes.html","tf":10.00943841434639},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.004234297812279464},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0051325919589392645},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.006417736289381563},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.010071090047393365},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0024982155603140615},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.007067137809187279},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0037209302325581397}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.004247286455875413},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.004719207173194903},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.011494252873563218},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"와":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"도":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"가":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"나":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"들":{"docs":{},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0033112582781456954},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"만":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0030701754385964912},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.006134969325153374},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.006516587677725118},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"처":{"docs":{},"럼":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}},"부":{"docs":{},"터":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}},"뿐":{"docs":{},"만":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"라":{"docs":{},"면":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"형":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.003500583430571762}}},")":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002962085308056872}}}}},"엔":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"내":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"안":{"docs":{},"의":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"식":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"릭":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764}},"'":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"'":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}},"그":{"docs":{},"런":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"그":{"docs":{},"런":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}}}}},"라":{"docs":{},"이":{"docs":{},"언":{"docs":{},"트":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"로":{"docs":{},"저":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"키":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"워":{"docs":{},"드":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"가":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"로":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}},"타":{"docs":{},"입":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.008025682182985553},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":5.010852713178295},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.007017543859649123},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004034065441506051},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.01834862385321101},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":5.029082774049217},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":5.015432098765432},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":5.022000369754114},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.002044989775051125},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0051325919589392645},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.014585764294049008},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":2.5096359743040684},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":5.0052576235541535},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.012367491166077738},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.006934812760055479},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.013245033112582781},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.008},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.01694915254237288},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.006688963210702341},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0032558139534883722}},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"도":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"은":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.004651162790697674},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002631578947368421},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.004806803475688667},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.006417736289381563},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0032119914346895075},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.005257623554153523},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"{":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.009302325581395349},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.004824561403508772},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.008516360376512775},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.011997177134791814},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.042505592841163314},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.005401234567901234},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.011092623405435386},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0023858214042263124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.004667444574095682},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.009635974304068522},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.01892744479495268},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.006934812760055479},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594}}},"이":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.006201550387596899},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002631578947368421},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0035285815102328866},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.015659955257270694},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0038580246913580245},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0033277870216306157},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0024982155603140615},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"라":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"도":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"어":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"므":{"docs":{},"로":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"며":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"든":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"나":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"거":{"docs":{},"나":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"스":{"docs":{},"크":{"docs":{},"립":{"docs":{},"트":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0016638935108153079},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"써":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"도":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"만":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"는":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.005263157894736842},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.004940014114326041},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.010030864197530864},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.004806803475688667},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.006309148264984227},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"인":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"가":{"docs":{},"?":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"과":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594}}},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"도":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"보":{"docs":{},"다":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},")":{"docs":{},"이":{"docs":{},"어":{"docs":{},"야":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}}}},"예":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"인":{"docs":{},"덱":{"docs":{},"스":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"t":{"docs":{},"가":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}},"들":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"과":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},"로":{"docs":{},"만":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"부":{"docs":{},"터":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}},"에":{"docs":{},"서":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"은":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"검":{"docs":{},"사":{"docs":{},"!":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546}}}}},"변":{"docs":{},"수":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"화":{"docs":{},"된":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"처":{"docs":{},"럼":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"\"":{"docs":{},"을":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"일":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"까":{"docs":{},"지":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"임":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},")":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"를":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"이":{"docs":{},"프":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"핑":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"(":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"n":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},"을":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}}}}}}}},"\"":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"은":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695}}},"이":{"docs":{},"기":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"란":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"을":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"임":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"만":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"/":{"docs":{},"디":{"docs":{},"자":{"docs":{},"인":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"게":{"docs":{},"팅":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}},"케":{"docs":{},"팅":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}},"하":{"docs":{},"는":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}},"협":{"docs":{},"하":{"docs":{},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"파":{"docs":{},"일":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004796163069544364},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.009193054136874362},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.004287756074321105},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.011570247933884297},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":2.5},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.004172461752433936},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00851063829787234},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.007525083612040134},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0225},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.004651162790697674}},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0028585040495474035},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005673758865248227},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"서":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}}},"는":{"docs":{},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"선":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}},"은":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0028585040495474035},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005673758865248227},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},"이":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0023820867079561697},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.009917355371900827},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.009929078014184398},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.004180602006688963},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"라":{"docs":{},"고":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"나":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231}}}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0054988216810683424},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.006197183098591549},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.013189448441247002},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.005107252298263534},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.006745362563237774},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.006193425440686041},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.011570247933884297},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.04044117647058824},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.005563282336578581},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.021333333333333333},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.01276595744680851},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.007525083612040134},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.005107252298263534},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"만":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"와":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}},"*":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{},"의":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{},"은":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}}},"과":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006611570247933884},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0070921985815602835},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.007525083612040134},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}}},"들":{"docs":{},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},":":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},"별":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},":":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"도":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"안":{"docs":{},"에":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}},"처":{"docs":{},"럼":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"/":{"docs":{},"디":{"docs":{},"렉":{"docs":{},"터":{"docs":{},"리":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"보":{"docs":{},"다":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"뿐":{"docs":{},"만":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"이":{"docs":{},"프":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"싱":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"을":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"라":{"docs":{},"미":{"docs":{},"터":{"docs":{},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"와":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"생":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"되":{"docs":{},"었":{"docs":{},"기":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"된":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0033034450212364322},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"될":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"악":{"docs":{},"할":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"패":{"docs":{},"키":{"docs":{},"지":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.013824884792626729}}},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.016},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"도":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"는":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.008},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005673758865248227}}},"의":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.006611570247933884},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333}}},"가":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.013333333333333334},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617}}},"들":{"docs":{},"은":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"을":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"와":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"만":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}}},"징":{"docs":{},"되":{"docs":{},"기":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"하":{"docs":{},"기":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"지":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}},"턴":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}},"들":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"을":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"과":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},"의":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}},"에":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"치":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"만":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"포":{"docs":{},"함":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"지":{"docs":{},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"여":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"지":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"게":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"기":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"도":{"docs":{},"록":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},"시":{"docs":{},"키":{"docs":{},"기":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"지":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"킬":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}},"킵":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},"\"":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}}}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}},"\"":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"@":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"*":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"되":{"docs":{},"어":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"야":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617}}},"고":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"며":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"면":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"해":{"docs":{},"야":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0070921985815602835},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"될":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},"과":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005673758865248227},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"\"":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"\"":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}},"동":{"docs":{},"봉":{"docs":{},"된":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}},")":{"docs":{},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"이":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"괄":{"docs":{},"할":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"맷":{"docs":{},"을":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"과":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},"에":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},"이":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}},"표":{"docs":{},"기":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"에":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"'":{"docs":{},"(":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"가":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"하":{"docs":{},"여":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"해":{"docs":{},"야":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}},"법":{"docs":{},"을":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"으":{"docs":{},"로":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"와":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"시":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"되":{"docs":{},"지":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"어":{"docs":{},"야":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"며":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"된":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"될":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"하":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"기":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"로":{"docs":{},"만":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"와":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"해":{"docs":{},"야":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}},"준":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"으":{"docs":{},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}},"과":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"현":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"식":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029171528588098016},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"에":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"서":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"나":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"라":{"docs":{},"고":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231}}},"만":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"으":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}},"의":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"과":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"하":{"docs":{},"기":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"할":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"해":{"docs":{},"야":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"한":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"에":{"docs":{},"서":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"으":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"이":{"docs":{},"나":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"플":{"docs":{},"러":{"docs":{},"그":{"docs":{},"인":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{},"y":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"과":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"에":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"은":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906}}},"이":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}},"래":{"docs":{},"그":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"인":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"와":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"랫":{"docs":{},"폼":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},")":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}}},"레":{"docs":{},"이":{"docs":{},"트":{"docs":{},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"필":{"docs":{},"드":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0032558139534883722}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0027906976744186047}}},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"서":{"docs":{},"는":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"는":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"요":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"하":{"docs":{},"지":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}},"다":{"docs":{},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"한":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"또":{"docs":{},"한":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"b":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"은":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}},"기":{"docs":{},"본":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}},"가":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"할":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"함":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"시":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}},"수":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"적":{"docs":{},"인":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"로":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"터":{"docs":{},"링":{"docs":{},"하":{"docs":{},"는":{"docs":{},"데":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"할":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}},"하":{"docs":{},"게":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},",":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"는":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"자":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"기":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.004771642808452625},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"위":{"docs":{},"해":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0040858018386108275},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"씩":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"와":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"만":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"써":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"이":{"docs":{},"기":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"임":{"docs":{},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"라":{"docs":{},"도":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"에":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},")":{"docs":{},"할":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"요":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"?":{"docs":{},"\"":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0027266530334014998},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"데":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"려":{"docs":{},"면":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"고":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"며":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"거":{"docs":{},"나":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"위":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0038580246913580245},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"서":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}}}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"인":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"타":{"docs":{},"입":{"docs":{},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"지":{"docs":{},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.005547850208044383},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"!":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}},"이":{"docs":{},"브":{"docs":{},"리":{"docs":{},"드":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"향":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"도":{"docs":{},"록":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}},"드":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"단":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"의":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"에":{"docs":{},"서":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"함":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}},"께":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.004815409309791332},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0035545023696682463},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"에":{"docs":{},"서":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"수":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.004815409309791332},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0037437603993344427},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.005701754385964913},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":10.008964589870013},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0056457304163726185},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.004629629629629629},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.005924170616113744},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0024982155603140615},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.007360672975814932},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0088339222614841},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"나":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0032102728731942215},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.003585835948005379},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014790164540580515},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"의":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002689376961004034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0038580246913580245},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}},"서":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"게":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0031376064545047063},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"(":{"docs":{},"i":{"docs":{},"i":{"docs":{},"f":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"e":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"y":{"docs":{},"m":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.006723442402510085},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"까":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"와":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"라":{"docs":{},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"면":{"docs":{},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004739336492890996},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}},"써":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"부":{"docs":{},"터":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"임":{"docs":{},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"처":{"docs":{},"럼":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"만":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"큼":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"들":{"docs":{},"이":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"안":{"docs":{},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"여":{"docs":{},"야":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"형":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005834305717619603}}},"이":{"docs":{},"므":{"docs":{},"로":{"docs":{},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},")":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"에":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},")":{"docs":{},"에":{"docs":{},"서":{"docs":{},"만":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"는":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"!":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},".":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003927729772191673},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0037437603993344427},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0021929824561403508},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.004719207173194903},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0044822949350067235},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0035285815102328866},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.006172839506172839},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00408997955010225},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.00505902192242833},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.004287756074321105},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00427715996578272},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.007001166861143524},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.014705882352941176},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0034770514603616135},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.010666666666666666},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0032558139534883722}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"t":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}},"그":{"docs":{},"렇":{"docs":{},"지":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"것":{"docs":{},"들":{"docs":{},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"프":{"docs":{},"로":{"docs":{},"젝":{"docs":{},"트":{"docs":{},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"향":{"docs":{},"후":{"docs":{},"에":{"docs":{},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}},"(":{"3":{"docs":{},")":{"docs":{},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"docs":{}},"다":{"docs":{},"행":{"docs":{},"히":{"docs":{},"도":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"w":{"docs":{},"e":{"docs":{},"b":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}},"유":{"docs":{},"효":{"docs":{},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"이":{"docs":{},"제":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"출":{"docs":{},"력":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"즉":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"n":{"docs":{},"p":{"docs":{},"m":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"만":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"까":{"docs":{},"?":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"집":{"docs":{},"합":{"docs":{},"이":{"docs":{},"라":{"docs":{},"면":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"쳐":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"진":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"칠":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"치":{"docs":{},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"도":{"docs":{},"록":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"지":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"성":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231}},"할":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"법":{"docs":{},"적":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}}}},"행":{"docs":{},"을":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}},"동":{"docs":{},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"일":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}},"형":{"docs":{},"태":{"docs":{},"를":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0033112582781456954}}},"가":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"뿐":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"의":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"이":{"docs":{},"고":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},")":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"식":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"인":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"을":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"성":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"고":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}},"호":{"docs":{},"출":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.005563282336578581}},"에":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}},"서":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"하":{"docs":{},"려":{"docs":{},"고":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"도":{"docs":{},"록":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"여":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},",":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"므":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"기":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"면":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"거":{"docs":{},"나":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"했":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}}}}},"만":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"은":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"한":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"해":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"야":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"서":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}},"될":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"들":{"docs":{},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"된":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"다":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"되":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"어":{"docs":{},"야":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"었":{"docs":{},"는":{"docs":{},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"면":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231}}},"지":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.02880658436213992},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"과":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"함":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498}}}}}},"의":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"이":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"환":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.004629629629629629},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}},"되":{"docs":{},"는":{"docs":{"pages/tutorials/TypeScript in 5 minutes.html":{"ref":"pages/tutorials/TypeScript in 5 minutes.html","tf":0.0016051364365971107}},"지":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"지":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"며":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"된":{"docs":{},"다":{"docs":{},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"될":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"성":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":5.000771604938271}},"에":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147}}},"은":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}}},"을":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0038580246913580245},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"이":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"스":{"docs":{},"트":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"팅":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}}},"$":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"{":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.005107252298263534}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"}":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"`":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"}":{"docs":{},"!":{"docs":{},"`":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"}":{"docs":{},"`":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},".":{"docs":{},"`":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"}":{"docs":{},"m":{"docs":{},".":{"docs":{},"`":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"}":{"docs":{},".":{"docs":{},"`":{"docs":{},";":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"}":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}}},"#":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"}":{"docs":{},"!":{"docs":{},"`":{"docs":{},")":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"}":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}},"p":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"}":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"`":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"(":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"나":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"*":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004796163069544364},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0033277870216306157},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.004430811179277437},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.00505902192242833},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.029978586723768737},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0027906976744186047}},"/":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.006745362563237774},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.023911491791577446},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.019417475728155338},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376}}},"]":{"docs":{},";":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"*":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}},"마":{"docs":{},"세":{"docs":{},"요":{"docs":{},"*":{"docs":{},"*":{"docs":{},"!":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"/":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"=":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"참":{"docs":{},"고":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"*":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"*":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}}}}}}}}}},"만":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"또":{"docs":{},"한":{"docs":{},"*":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"/":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}},"*":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.006745362563237774},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.019417475728155338}},"*":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.023911491791577446},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},"!":{"docs":{},"로":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"/":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.010704225352112675},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.01079136690647482},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.01937984496124031},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.016638935108153077},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.007456140350877193},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.008966493629070316},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.014791573285522188},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0077628793225123505},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.008723235527359239},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.008948545861297539},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.016975308641975308},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.02126086152708449},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.01646090534979424},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.018115942028985508},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.007839127471029312},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.010214504596527068},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.011120615911035072},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.01866977829638273},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.014367816091954023},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.013204853675945753},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.04206098843322818},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.005563282336578581},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.013869625520110958},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.009933774834437087},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00911854103343465},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.026976744186046512}},"/":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.005107252298263534},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.00505902192242833},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.02975206611570248},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0034770514603616135},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.013333333333333334}},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{},"/":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"출":{"docs":{},"력":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"\\":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"$":{"docs":{},"/":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}},"t":{"docs":{},"s":{"docs":{},"x":{"docs":{},"?":{"docs":{},"$":{"docs":{},"/":{"docs":{},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}}},"(":{"docs":{},"x":{"docs":{},"?":{"docs":{},")":{"docs":{},"$":{"docs":{},"/":{"docs":{},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}},"s":{"docs":{},"r":{"docs":{},"/":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"@":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"j":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"/":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"j":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"^":{"docs":{},"[":{"0":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}},"docs":{},"a":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"/":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"/":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"/":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{},"s":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}}}},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"/":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"@":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"j":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"/":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"j":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"/":{"docs":{},"a":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"안":{"docs":{},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"s":{"docs":{},"안":{"docs":{},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}},"b":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}}},"j":{"docs":{},"s":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"/":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"/":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"파":{"docs":{},"일":{"docs":{},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"@":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"j":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"/":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"j":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"s":{"docs":{},"x":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}}}}},"으":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}}}}}}}},"@":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"{":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"u":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"은":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}},"t":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.013204853675945753},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"s":{"docs":{},"/":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}},"l":{"docs":{},"o":{"docs":{},"d":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736}}}}}}},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"/":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"에":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}}}}}}}}}}}},"m":{"docs":{},"y":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}}}}}}},",":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},")":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"안":{"docs":{},"에":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"에":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"의":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0024982155603140615}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"와":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"{":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}},"과":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"은":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0032119914346895075}}}}}}}},"h":{"docs":{},"i":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}},"s":{"docs":{},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"j":{"docs":{},"s":{"docs":{},"x":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}}}},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0017844396859386152}},"e":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}},"데":{"docs":{},"코":{"docs":{},"레":{"docs":{},"이":{"docs":{},"터":{"docs":{},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}}}}}}}}}},"은":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922}},"s":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}},"f":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}},"(":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231}}}}}}}}}}}}}}}},"g":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}},"(":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},":":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0028551034975017845}},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}},"e":{"docs":{},"d":{"docs":{},"가":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"를":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004146919431279621}}}}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}},"u":{"docs":{},"g":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"s":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.011063526052819414}},"과":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"은":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}}}}},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0021413276231263384}}}}}}},"t":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"e":{"docs":{},"은":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"은":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"]":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00425531914893617},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231}},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},";":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"`":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}}}},"m":{"docs":{},"i":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"{":{"docs":{},"}":{"docs":{},"`":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"`":{"docs":{},"의":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}},"`":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"a":{"docs":{},"`":{"docs":{},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"`":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"x":{"docs":{},"`":{"docs":{},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"`":{"docs":{},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"`":{"docs":{},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"`":{"docs":{},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"`":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"`":{"docs":{},"의":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"`":{"docs":{},"을":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}}}}}}}}}}}}}}}}},"`":{"docs":{},"`":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}},"t":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"`":{"docs":{},"를":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}},"b":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.004991680532445923},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0023820867079561697},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.010214504596527068},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"e":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"t":{"docs":{},"a":{"docs":{},".":{"1":{"1":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}},"docs":{}},"2":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"docs":{}}},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}}}}},"n":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}},"e":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},"p":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}}},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},"e":{"docs":{},"r":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}}}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"f":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},")":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.04013377926421405},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0925}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}}},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"]":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},";":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.011494252873563218},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.007067137809187279}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}}}}}}}}}}}}}}}}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"}":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"'":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}},"m":{"docs":{},"!":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"b":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{},"`":{"docs":{},";":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"p":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"s":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"d":{"docs":{},"y":{"docs":{},"가":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}},"x":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323}},"e":{"docs":{},"d":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"e":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}}}}}}}}}}}},"r":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"문":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"r":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.007855459544383346},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0121580547112462}}},"y":{"docs":{},"(":{"docs":{},"{":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}},")":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.008}}},"는":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"t":{"docs":{},"\"":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}}}},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.027579162410623085},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895}}}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004034065441506051}}}}}}},"j":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"p":{"docs":{},"h":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"e":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0031376064545047063}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}}}}}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}},"s":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}}}}}}}}},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}},"s":{"docs":{},".":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}},"에":{"docs":{},"는":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"t":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204}},"d":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}},"'":{"docs":{},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}}}}},"와":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}}}}}},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},")":{"docs":{},";":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},".":{"docs":{},"j":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"s":{"docs":{},"가":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"0":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"docs":{}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003927729772191673}},",":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"y":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"도":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"은":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"과":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},")":{"docs":{},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"에":{"docs":{},"서":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"s":{"docs":{},"e":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339}}}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"과":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017}}},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609}}}}}}}}},"i":{"docs":{},"c":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"docs":{}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}}}}}}}}}}}},"g":{"docs":{},"s":{"docs":{},"\"":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"r":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.006622516556291391},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"k":{"docs":{},"(":{"docs":{},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"와":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},";":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"?":{"docs":{},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"가":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"(":{"1":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}},"docs":{},"a":{"docs":{},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},".":{"docs":{},"a":{"docs":{},";":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"로":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"를":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"/":{"docs":{},"t":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},".":{"docs":{},"j":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}}}}}}}}}}}}},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}},"z":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},".":{"docs":{},"d":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"j":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}}}},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},".":{"docs":{},"f":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},")":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"}":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837}}},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0024958402662229617},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0017844396859386152},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.004206098843322818},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079}}},"=":{"0":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"docs":{}},"?":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"]":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"c":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},".":{"docs":{},"t":{"docs":{},"s":{"docs":{},"가":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}},"—":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386}}},"검":{"docs":{},"사":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.003500583430571762},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":2.5007137758743756},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.003875968992248062},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0021929824561403508},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.002333722287047841},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"하":{"docs":{},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}},"여":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"면":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"한":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"기":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.007150153217568948}},"를":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}}},"해":{"docs":{},"야":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"되":{"docs":{},"지":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"므":{"docs":{},"로":{"docs":{},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"와":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"색":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},"할":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}}}},"이":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"증":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"해":{"docs":{},"야":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}},"교":{"docs":{},"체":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851}}}}}},"하":{"docs":{},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}},"차":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0018487705675725643}}},"환":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"끝":{"docs":{},"난":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"납":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}},"냈":{"docs":{},"나":{"docs":{},"요":{"docs":{},"?":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"의":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"대":{"docs":{},"신":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002689376961004034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0035285815102328866},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.004180602006688963}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"해":{"docs":{},"서":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"주":{"docs":{},"지":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}},")":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"체":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"하":{"docs":{},"세":{"docs":{},"요":{"docs":{},":":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"는":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"려":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"할":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017}}}},"한":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.004713275726630008},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0018487705675725643},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.002044989775051125},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.006745362563237774},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0028585040495474035},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.011255924170616114},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0034770514603616135},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.0060790273556231},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}}},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"상":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.005401234567901234},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"으":{"docs":{},"로":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.004180602006688963},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"한":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"서":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"이":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"며":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"들":{"docs":{},"이":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"의":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"부":{"docs":{},"분":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"해":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"서":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"만":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"개":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"응":{"docs":{},"되":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"하":{"docs":{},"기":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}}}},"인":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}},"답":{"docs":{},"해":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"안":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},":":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}}},"조":{"docs":{},"적":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}}},"수":{"docs":{},"적":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"규":{"docs":{},"모":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"문":{"docs":{},"자":{"docs":{},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"게":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"괄":{"docs":{},"호":{"docs":{},"로":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"하":{"docs":{},"여":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"데":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00823045267489712},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"코":{"docs":{},"레":{"docs":{},"이":{"docs":{},"터":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":10.015402843601896},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0071090047393364926}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"서":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.017180094786729858}}},"를":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.005924170616113744}}},"와":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004146919431279621}}}},"팅":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}},"된":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}},"이":{"docs":{},"터":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0031007751937984496},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"를":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"베":{"docs":{},"이":{"docs":{},"스":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"와":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"이":{"docs":{},"며":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}},"에":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}}},"만":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"로":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}},"들":{"docs":{},"어":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}},"가":{"docs":{},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"기":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588}}}},"있":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.004651162790697674},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0020336476243298205},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.005563282336578581},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0021413276231263384},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}},"보":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}},"간":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"갈":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"디":{"docs":{},"버":{"docs":{},"그":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"거":{"docs":{},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"가":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}},"깅":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"고":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"할":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"을":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}},"렉":{"docs":{},"토":{"docs":{},"리":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"부":{"docs":{},"터":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"서":{"docs":{},"부":{"docs":{},"터":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}},"의":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"와":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"는":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"로":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"터":{"docs":{},"리":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0028585040495474035},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.004651162790697674}},",":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017}}},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0028585040495474035},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"부":{"docs":{},"터":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"게":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"티":{"docs":{},"브":{"docs":{},"를":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968}}}}}},"폴":{"docs":{},"트":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"자":{"docs":{},"인":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"때":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0031007751937984496},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.002831524303916942},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.006711409395973154},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.005016722408026756},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"마":{"docs":{},"다":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}}},"문":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.002831524303916942},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0038580246913580245},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.005547850208044383},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.004186046511627907}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002631578947368421},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.008},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},")":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},":":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}}},")":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}}}}},"이":{"docs":{},"고":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"때":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}},"로":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0035087719298245615},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0016638935108153079},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}}},"만":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"나":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"도":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"만":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"와":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},".":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"까":{"docs":{},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},")":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},"드":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"p":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}}}}}}},"하":{"docs":{},"도":{"docs":{},"록":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"여":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"기":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"에":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"는":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"려":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"할":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},"되":{"docs":{},"는":{"docs":{},"지":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"므":{"docs":{},"로":{"docs":{},"(":{"docs":{},"모":{"docs":{},"듈":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}},"어":{"docs":{},"야":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"된":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"컬":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"에":{"docs":{"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}},"서":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"그":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"를":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}},"깅":{"docs":{},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"더":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0034770514603616135}},"보":{"docs":{},"다":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"인":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"로":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"에":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"서":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"는":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"(":{"docs":{},"예":{"docs":{},":":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}},"\"":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"딩":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0034083162917518746},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"과":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"직":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"은":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"케":{"docs":{},"일":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"먼":{"docs":{},"저":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.003142183817753339},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}},"메":{"docs":{},"시":{"docs":{},"지":{"docs":{},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"서":{"docs":{},"드":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.005924170616113744},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.01646090534979424}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"가":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"(":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471}}},"와":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"들":{"docs":{},"은":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.02880658436213992}}}}}},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"도":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"서":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}},"커":{"docs":{},"니":{"docs":{},"즘":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"에":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}}},"소":{"docs":{},"드":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"로":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"개":{"docs":{},"변":{"docs":{},"수":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}},"타":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"데":{"docs":{},"이":{"docs":{},"터":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002962085308056872}},"를":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}}}},"인":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.010666666666666666}}},"세":{"docs":{},"지":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}}},"모":{"docs":{},"리":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"부":{"docs":{},"르":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"동":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}}},"울":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"릅":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}},"분":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}},"들":{"docs":{},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}},"으":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"집":{"docs":{},"합":{"docs":{},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"인":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}},"이":{"docs":{},"며":{"docs":{},",":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"서":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"클":{"docs":{},"래":{"docs":{},"스":{"docs":{},"를":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"터":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}},"호":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"수":{"docs":{},"효":{"docs":{},"과":{"docs":{},"만":{"docs":{},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},"여":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"족":{"docs":{},"하":{"docs":{},"여":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"거":{"docs":{},"나":{"docs":{},"/":{"docs":{},"혹":{"docs":{},"은":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}},"빌":{"docs":{},"드":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0028169014084507044},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0023820867079561697},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":3.3394123606889563},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":5}},"가":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"의":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"한":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"간":{"docs":{},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"하":{"docs":{},"여":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"는":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}},"는":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},")":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"빨":{"docs":{},"간":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}},"선":{"docs":{},"이":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"리":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"선":{"docs":{},"언":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004796163069544364},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":5.003327787021631},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":5.005988023952096},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.008886255924170616},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.013223140495867768},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.04779411764705882},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.009735744089012517},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.015901060070671377},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.01434878587196468},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.04},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.022598870056497175},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00427715996578272},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0035545023696682463},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.010666666666666666},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"된":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"했":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}},"하":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}},"지":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"면":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"려":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},"며":{"docs":{},";":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"기":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}}}},"과":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"되":{"docs":{},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"어":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"야":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}},"었":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"지":{"docs":{},"만":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"음":{"docs":{},"을":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"다":{"docs":{},"고":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"지":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"될":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0035545023696682463},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"는":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0024958402662229617},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.005988023952095809},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.005518763796909493},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"한":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"으":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"부":{"docs":{},"터":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"도":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}},"(":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}},"들":{"docs":{},"은":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"만":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"해":{"docs":{},"야":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"형":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},"부":{"docs":{},"에":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002962085308056872}}}}}},"문":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"을":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"도":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"택":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"하":{"docs":{},"고":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.004028197381671702}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"여":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"기":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}},"보":{"docs":{},"단":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"므":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"적":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002631578947368421},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.004034065441506051},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.004629629629629629},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0032119914346895075},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.008321775312066574},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"으":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.006934812760055479}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"고":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"어":{"docs":{},"야":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"일":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"인":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"해":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},"야":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"한":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"할":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}},"사":{"docs":{},"항":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"된":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"호":{"docs":{},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"되":{"docs":{},"는":{"docs":{},"지":{"docs":{},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"하":{"docs":{},"는":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}}},"손":{"docs":{},"쉽":{"docs":{},"게":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"으":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"스":{"docs":{},"타":{"docs":{},"트":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"일":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"이":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"로":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"을":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"크":{"docs":{},"립":{"docs":{},"트":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"를":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"스":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"왑":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"코":{"docs":{},"프":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.005823627287853577},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"라":{"docs":{},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"인":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}},"핑":{"docs":{},"(":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"c":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}}},"태":{"docs":{},"틱":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"이":{"docs":{},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}},"텝":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"은":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}},"프":{"docs":{},"레":{"docs":{},"드":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"칼":{"docs":{},"라":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}},"키":{"docs":{},"마":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"위":{"docs":{},"치":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"니":{"docs":{},"펫":{"docs":{},"을":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"쓰":{"docs":{},"지":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"이":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"군":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"게":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"일":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546}}},"도":{"docs":{},"록":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546}}}},"인":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"여":{"docs":{},"지":{"docs":{},"기":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"앵":{"docs":{},"귤":{"docs":{},"러":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"업":{"docs":{},"데":{"docs":{},"이":{"docs":{},"트":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"된":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"할":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"하":{"docs":{},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"여":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"세":{"docs":{},"요":{"docs":{},":":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.009216589861751152}}}}},"기":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"가":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"그":{"docs":{},"레":{"docs":{},"이":{"docs":{},"드":{"docs":{},"하":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}}}}},"연":{"docs":{},"결":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"(":{"docs":{},"p":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}}},"했":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"여":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"할":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"의":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"산":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"자":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"로":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"들":{"docs":{},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"으":{"docs":{},"로":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}}},"관":{"docs":{},"된":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}},"기":{"docs":{},"된":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"하":{"docs":{},"겠":{"docs":{},"다":{"docs":{},"면":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"저":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"장":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"한":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"할":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"된":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}},"좋":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.008}},"(":{"docs":{},"아":{"docs":{},"래":{"docs":{},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"은":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"아":{"docs":{},"요":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"았":{"docs":{},"어":{"docs":{},"!":{"docs":{},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}}}}},"게":{"docs":{},"도":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"음":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.009708737864077669}}}},"준":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"비":{"docs":{},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"됐":{"docs":{},"나":{"docs":{},"요":{"docs":{},"?":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}},"줄":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.0049586776859504135},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}},"은":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"도":{"docs":{},"록":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"지":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"일":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"여":{"docs":{},"주":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"의":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"중":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"인":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.002014098690835851},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"지":{"docs":{},"하":{"docs":{},"고":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"했":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"간":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"요":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},":":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"하":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}},"다":{"docs":{},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"한":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"복":{"docs":{},"해":{"docs":{},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"첩":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625}},"된":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"될":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"하":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"괄":{"docs":{},"호":{"docs":{},"(":{"docs":{},"{":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"단":{"docs":{},"하":{"docs":{},"지":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"점":{"docs":{},"을":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"즉":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"시":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}},"직":{"docs":{},"접":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"관":{"docs":{},"적":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},".":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}},"인":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},"만":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"렬":{"docs":{},"로":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}},"전":{"docs":{},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231}}}}},"차":{"docs":{},"이":{"docs":{},"점":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"이":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"별":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"용":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"찾":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356}}}}}},"은":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"아":{"docs":{},"냈":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"내":{"docs":{},"는":{"docs":{},"지":{"docs":{},"를":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}},"야":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588}},"데":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"았":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}},"다":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"면":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"지":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"고":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"자":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}},"기":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}},"지":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"도":{"docs":{},"록":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"으":{"docs":{},"려":{"docs":{},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356}}}},"실":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}}},"음":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}}},"최":{"docs":{},"신":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}}},"상":{"docs":{},"위":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0023858214042263124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.004172461752433936},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0037209302325581397}}}},"선":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}},"종":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0023820867079561697},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"대":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"한":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"소":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"한":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"적":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.015659955257270694}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"화":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"할":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"근":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"에":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"취":{"docs":{},"소":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}}}},"하":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"려":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"여":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"급":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"할":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"하":{"docs":{},"지":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"고":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}},"됨":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"할":{"docs":{},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"퀵":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"탐":{"docs":{},"색":{"docs":{},"기":{"docs":{},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"하":{"docs":{},"면":{"docs":{},"서":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"할":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"지":{"docs":{},"할":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"태":{"docs":{},"스":{"docs":{},"크":{"docs":{},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}}},"그":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"라":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"를":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0040858018386108275},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0017844396859386152},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"로":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"(":{"docs":{},"@":{"docs":{},"a":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}}},"들":{"docs":{},"은":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"탭":{"docs":{},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255}}}},"테":{"docs":{},"스":{"docs":{},"트":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}},"하":{"docs":{},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{},"페":{"docs":{},"이":{"docs":{},"지":{"docs":{},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}},"여":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"할":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"를":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"이":{"docs":{},"터":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"페":{"docs":{},"이":{"docs":{},"지":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}},"가":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"도":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"에":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},"서":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"의":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}},"폴":{"docs":{},"더":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"를":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},"에":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}},"리":{"docs":{},"필":{"docs":{},"(":{"docs":{},"p":{"docs":{},"o":{"docs":{},"l":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},")":{"docs":{},"을":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}}}}}},"될":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"링":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}},"할":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.003943661971830986},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.004796163069544364},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.002831524303916942},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0016638935108153079},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.005112474437627812},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0033349213911386373},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00427715996578272},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.005747126436781609},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.014705882352941176},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0027906976744186047}},"당":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.004651162790697674},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0024034017378443337},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"지":{"docs":{},"를":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"되":{"docs":{},"었":{"docs":{},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"던":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"어":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"기":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"하":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"여":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"고":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}},"받":{"docs":{},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},".":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}},"될":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"의":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"과":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"이":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0038580246913580245}}},"된":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"서":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"라":{"docs":{},"도":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"필":{"docs":{},"요":{"docs":{},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"때":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"까":{"docs":{},"요":{"docs":{},"?":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"항":{"docs":{},"목":{"docs":{},"을":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0030211480362537764},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0028585040495474035},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"상":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0027906976744186047}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"루":{"docs":{},"프":{"docs":{},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}}},"후":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"에":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"는":{"docs":{"pages/tutorials/ASP.NET Core.html":{"ref":"pages/tutorials/ASP.NET Core.html","tf":0.0010070493454179255},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"위":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"보":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.017897091722595078}},"가":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},",":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}},"반":{"docs":{},"부":{"docs":{},"로":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}},"~":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"/":{"docs":{},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"/":{"docs":{},"g":{"docs":{},"u":{"docs":{},"l":{"docs":{},"p":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"j":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}}}}}}}}}}}}}}}}},"~":{"docs":{},"~":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"~":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"~":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}},"~":{"docs":{},"~":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"~":{"docs":{},"~":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"~":{"docs":{},"~":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{},"~":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}}}}}}}}}}}},"└":{"docs":{},"─":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}},"─":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.004764173415912339}},"─":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"s":{"docs":{},"r":{"docs":{},"c":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}},"├":{"docs":{},"─":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},"─":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356}},"─":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}}}}}}},"걸":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}},"프":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":10}},",":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}},"쳐":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"고":{"docs":{},"침":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"급":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":5.000184877056757},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"스":{"docs":{},"럽":{"docs":{},"게":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}},"유":{"docs":{},"한":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"하":{"docs":{},"지":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"해":{"docs":{},"야":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"정":{"docs":{},"된":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"되":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"려":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"하":{"docs":{},"여":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"지":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}}}}},"해":{"docs":{},"야":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"봅":{"docs":{},"시":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"했":{"docs":{},"으":{"docs":{},"며":{"docs":{},",":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}},"맙":{"docs":{},"게":{"docs":{},"도":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"치":{"docs":{},"도":{"docs":{},"록":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"기":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}},"통":{"docs":{},"스":{"docs":{},"러":{"docs":{},"운":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"를":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"립":{"docs":{},"성":{"docs":{},"과":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}},"품":{"docs":{},"질":{"docs":{},"의":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}}},"골":{"docs":{},"격":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"광":{"docs":{},"범":{"docs":{},"위":{"docs":{},"한":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"하":{"docs":{},"게":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}},"글":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"로":{"docs":{},"벌":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"은":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}},"난":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"독":{"docs":{},"화":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"노":{"docs":{},"드":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004}}}},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"출":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"되":{"docs":{},"며":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"된":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625}}},"하":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"므":{"docs":{},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"기":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}},":":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}},"트":{"docs":{},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"력":{"docs":{},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"하":{"docs":{},"고":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}}},"돌":{"docs":{},"아":{"docs":{},"가":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"기":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"와":{"docs":{},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"둘":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"째":{"docs":{},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"은":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"러":{"docs":{},"싸":{"docs":{},"서":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"루":{"docs":{},"트":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0015710919088766694},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.0035971223021582736},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"가":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"임":{"docs":{},"을":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"프":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347}}},"를":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.010869565217391304}}},"에":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}}}},"맞":{"docs":{},"춤":{"docs":{},"형":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"지":{"docs":{},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"추":{"docs":{},"고":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},"기":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"어":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"게":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"닥":{"docs":{},"뜨":{"docs":{},"리":{"docs":{},"면":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}},"맵":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.002356637863315004},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}}},"이":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"(":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"s":{"docs":{},")":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}},"과":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"으":{"docs":{},"로":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"핑":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"이":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"묶":{"docs":{},"어":{"docs":{},"서":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"지":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}}},"인":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"믹":{"docs":{},"스":{"docs":{},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"인":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":10}},"이":{"docs":{},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"에":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}},"받":{"docs":{},"게":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"것":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"아":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}},"서":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"들":{"docs":{},"일":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"았":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"백":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"그":{"docs":{},"라":{"docs":{},"운":{"docs":{},"드":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"틱":{"docs":{},"/":{"docs":{},"백":{"docs":{},"쿼":{"docs":{},"트":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}}},"업":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"별":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}},"도":{"docs":{},"의":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"로":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"칭":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0033112582781456954}},")":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"과":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"보":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014790164540580515}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"으":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"이":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}},"인":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"개":{"docs":{},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"세":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}},"계":{"docs":{},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"밀":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"부":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"트":{"docs":{},"를":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"션":{"docs":{},"을":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"쉬":{"docs":{},"운":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"워":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"집":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"졌":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}}}}},"울":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"압":{"docs":{},"축":{"docs":{},"되":{"docs":{},"는":{"docs":{},"지":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"하":{"docs":{},"기":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}}},"도":{"docs":{},"하":{"docs":{},"여":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"앞":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"만":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"쪽":{"docs":{},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"엔":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"약":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"간":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"은":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"칭":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}},"엉":{"docs":{},"망":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"원":{"docs":{},"본":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.005401234567901234},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"과":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"에":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"하":{"docs":{},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"대":{"docs":{},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}},"거":{"docs":{},"나":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}},"래":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"(":{"docs":{},"병":{"docs":{},"합":{"docs":{},"되":{"docs":{},"지":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}}},"천":{"docs":{},"이":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"치":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"할":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"시":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}},"형":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"인":{"docs":{},"이":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}},"칙":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"한":{"docs":{},"다":{"docs":{},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"했":{"docs":{},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}},"접":{"docs":{},"근":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.002831524303916942},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}},"할":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0024958402662229617},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"하":{"docs":{},"면":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"기":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"지":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"며":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"거":{"docs":{},"나":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"해":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"자":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.005924170616113744}},"가":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"를":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}},"의":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}},"으":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"이":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"법":{"docs":{},"이":{"docs":{},"라":{"docs":{},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}},"두":{"docs":{},"사":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"어":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"미":{"docs":{},"사":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"처":{"docs":{},"리":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}},"하":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"는":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942}}}},"된":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155}}},"(":{"docs":{},"모":{"docs":{},"듈":{"docs":{},"에":{"docs":{},"서":{"docs":{},"도":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}},")":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"한":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"되":{"docs":{},"며":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"는":{"docs":{},"지":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"고":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},"럼":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}},")":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"음":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"초":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}},"기":{"docs":{},"화":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.003965107057890563},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"할":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}},"해":{"docs":{},"야":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"가":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"되":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376}}}},"된":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"하":{"docs":{},"고":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"더":{"docs":{},"라":{"docs":{},"도":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"될":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"에":{"docs":{},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"과":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"한":{"docs":{},"다":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"점":{"docs":{},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},"월":{"docs":{},"한":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"심":{"docs":{},"자":{"docs":{},"에":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}},"래":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"출":{"docs":{},"력":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0037437603993344427},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.004180602006688963},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0027906976744186047}},"과":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"은":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}},"을":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}},"이":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"는":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"물":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"을":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"하":{"docs":{},"도":{"docs":{},"록":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0033444816053511705},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}}}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"된":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"했":{"docs":{},"을":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"발":{"docs":{},"점":{"docs":{},"이":{"docs":{},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}},"처":{"docs":{},"인":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}},"콘":{"docs":{},"솔":{"docs":{},"에":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"텐":{"docs":{},"츠":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"텍":{"docs":{},"스":{"docs":{},"트":{"docs":{},"에":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},"텍":{"docs":{},"스":{"docs":{},"트":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}},"를":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}}},"튜":{"docs":{},"토":{"docs":{},"리":{"docs":{},"얼":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"는":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"이":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"플":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0031007751937984496},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}}},"편":{"docs":{},"집":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}}},"리":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"한":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"이":{"docs":{},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"의":{"docs":{},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"하":{"docs":{},"게":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"한":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"했":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"!":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"으":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/tutorials/Gulp.html":{"ref":"pages/tutorials/Gulp.html","tf":0.0007855459544383347}}}}},"듯":{"docs":{},"이":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"던":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"고":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"!":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"[":{"1":{"docs":{},"]":{"docs":{},")":{"docs":{},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"=":{"docs":{},"=":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625}}}},"(":{"docs":{},"s":{"docs":{},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}},"&":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":3.333333333333333},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0014790164540580515},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.005257623554153523},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}},"&":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0034083162917518746},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"x":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0029118136439267887},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.007171671896010758},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.008948545861297539},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.005401234567901234},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.004252172305416898},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0032119914346895075},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.013245033112582781}},",":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0031545741324921135},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.005547850208044383},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.00772626931567329}}},"[":{"3":{"docs":{},"]":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"docs":{}},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},";":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0024958402662229617},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0038580246913580245},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}}}}},".":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}}}}}}},"y":{"docs":{},".":{"docs":{},"z":{"docs":{},"를":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"docs":{},"\"":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"f":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},",":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}}}}}}}}}}}}}},"z":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}}},"가":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"라":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"고":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"(":{"4":{"2":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"docs":{}},"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},";":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}}}},"y":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}}}}}},"에":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}}},"와":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"m":{"docs":{},"l":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"y":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.005401234567901234},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594}},")":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}},")":{"docs":{},";":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}}}},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},":":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.002831524303916942},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002689376961004034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594}}},"e":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}},"a":{"docs":{},"r":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"h":{"docs":{},"u":{"docs":{},"d":{"docs":{},"a":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}},")":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002689376961004034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0038580246913580245},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.004629629629629629},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}}},"?":{"docs":{},")":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"가":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"에":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098}},"서":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"의":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"o":{"docs":{},"u":{"docs":{},"'":{"docs":{},"r":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625}}},"d":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}},"l":{"docs":{},"l":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.005107252298263534}}}}}}},"(":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},".":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"docs":{},"\"":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}}}}}}},"|":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.01608430393788131},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0035688793718772305},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.007360672975814932},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"|":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0009243852837862821},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}}},"│":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.004287756074321105}}},"각":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0023596035865974517},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0016638935108153079},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.003067484662576687},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.006128702757916241},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0019056693663649356},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0051325919589392645},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.005333333333333333},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"각":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"의":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"자":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"주":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}},"가":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"를":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"값":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005250875145857643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.013245033112582781},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"서":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0031007751937984496},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.004758128469468675},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.00772626931567329},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},"과":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"들":{"docs":{},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"이":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"의":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.005518763796909493}}},"이":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0031007751937984496},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0055511498810467885},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"든":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"라":{"docs":{},"고":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"기":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.012345679012345678}}}}}},"으":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0016638935108153079},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"인":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"만":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}},"일":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"도":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"걱":{"docs":{},"정":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"하":{"docs":{},"지":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"할":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"곳":{"docs":{},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"도":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"나":{"docs":{},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"으":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"이":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"과":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"을":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"공":{"docs":{},"백":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"통":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.017897091722595078},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},"된":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"성":{"docs":{},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"인":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"개":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"된":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"유":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"함":{"docs":{},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"간":{"docs":{},"에":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"변":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"식":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}},"꽤":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"너":{"docs":{},"무":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.002689376961004034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}},"나":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"높":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"일":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"이":{"docs":{},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}},"느":{"docs":{},"껴":{"docs":{},"질":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"슨":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"함":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"한":{"docs":{},"\"":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}},"낄":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"끼":{"docs":{},"실":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"꼈":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"려":{"docs":{},"질":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"리":{"docs":{},"게":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"덜":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}},"어":{"docs":{},"주":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"덮":{"docs":{},"어":{"docs":{},"쓰":{"docs":{},"기":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"도":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"데":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"쓸":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"씁":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}}},"된":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0033112582781456954}},"다":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"뒤":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}},"있":{"docs":{},"는":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}},"따":{"docs":{},"라":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}},"오":{"docs":{},"는":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}},"르":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"뛰":{"docs":{},"어":{"docs":{},"난":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"레":{"docs":{},"벨":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.004186046511627907}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625}},"서":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"만":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"의":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},"이":{"docs":{},"거":{"docs":{},"나":{"docs":{},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"이":{"docs":{},"아":{"docs":{},"웃":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"과":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"을":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"어":{"docs":{},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"블":{"docs":{},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"퍼":{"docs":{},"런":{"docs":{},"스":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":5}},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"말":{"docs":{},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}},"해":{"docs":{},"주":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"듯":{"docs":{},"이":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"서":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"씀":{"docs":{},"드":{"docs":{},"리":{"docs":{},"자":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}},"은":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},")":{"docs":{},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}}},"하":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"려":{"docs":{},"는":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"자":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"했":{"docs":{},"듯":{"docs":{},"이":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"아":{"docs":{},"야":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588}}}}},"무":{"docs":{},"언":{"docs":{},"가":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"라":{"docs":{},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"슨":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"일":{"docs":{},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"시":{"docs":{},"할":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"하":{"docs":{},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}},";":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}},"조":{"docs":{},"건":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"적":{"docs":{},"인":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"엇":{"docs":{},"인":{"docs":{},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"가":{"docs":{},"?":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"이":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732}},"든":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"일":{"docs":{},"까":{"docs":{},"요":{"docs":{},"?":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}}}},"한":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"한":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"관":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"상":{"docs":{},"태":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"묵":{"docs":{},"시":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"물":{"docs":{},"론":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"리":{"docs":{},"적":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"음":{"docs":{},"표":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"반":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"환":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0031007751937984496},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0024958402662229617},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.002631578947368421},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.005378753922008068},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.002117148906139732},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0030864197530864196},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.008321775312066574}},"문":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"이":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}},"하":{"docs":{},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0017929179740026895},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00823045267489712},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"거":{"docs":{},"나":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},",":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"기":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"고":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}},"면":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"도":{"docs":{},"록":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}},"된":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"다":{"docs":{},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"했":{"docs":{},"다":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"될":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"되":{"docs":{},"는":{"docs":{},"지":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"한":{"docs":{},"다":{"docs":{},".":{"docs":{},"\"":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}}},"값":{"docs":{},"을":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"이":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"대":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"여":{"docs":{},"도":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},")":{"docs":{},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"드":{"docs":{},"시":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.011029411764705883},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0034770514603616135},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}},"복":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"될":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"마":{"docs":{},"다":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}},"자":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}},"를":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}},"는":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}},"되":{"docs":{},"는":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.010869565217391304}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}},";":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}}}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}},"영":{"docs":{},"하":{"docs":{},"도":{"docs":{},"록":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"기":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"되":{"docs":{},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"해":{"docs":{},"야":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"면":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"에":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}},"벅":{"docs":{},"차":{"docs":{},"다":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"범":{"docs":{},"위":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}},"서":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"의":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"베":{"docs":{},"이":{"docs":{},"스":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"에":{"docs":{},"서":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"는":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"열":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"병":{"docs":{},"합":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":5.005132591958939},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"하":{"docs":{},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"기":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"는":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}},"지":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"려":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},"(":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}},"되":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"며":{"docs":{},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"어":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}},"지":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"할":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176}}},"\"":{"docs":{},"은":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"'":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"된":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.007698887938408896}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},":":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},"은":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"을":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"의":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"이":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}},"불":{"docs":{},"평":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"러":{"docs":{},"오":{"docs":{},"기":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}},"리":{"docs":{},"언":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"(":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},")":{"docs":{},"에":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"기":{"docs":{},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"하":{"docs":{},"여":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"가":{"docs":{},"능":{"docs":{},"하":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"한":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"할":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}},"변":{"docs":{},"이":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"하":{"docs":{},"며":{"docs":{"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}},"다":{"docs":{},"고":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}},"행":{"docs":{},"히":{"docs":{},"도":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"하":{"docs":{},"게":{"docs":{},"도":{"docs":{},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"문":{"docs":{},"하":{"docs":{},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"확":{"docs":{},"실":{"docs":{},"한":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"구":{"docs":{},"하":{"docs":{},"고":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"짜":{"docs":{},"리":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"필":{"docs":{},"요":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"한":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}},"렸":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}}},"과":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"비":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.008099094807050978},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"밀":{"docs":{},"스":{"docs":{},"러":{"docs":{},"운":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"슷":{"docs":{},"한":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},",":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"게":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546}}},"만":{"docs":{},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},")":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"교":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},"적":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"할":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147}}},"하":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"될":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"어":{"docs":{},"있":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"을":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"공":{"docs":{},"개":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.002831524303916942},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.009302325581395349}},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"(":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}}},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"가":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"와":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"이":{"docs":{},"기":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"워":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}},"두":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"용":{"docs":{},"을":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"롯":{"docs":{},"된":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"활":{"docs":{},"성":{"docs":{},"화":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"할":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"빼":{"docs":{},"먹":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"고":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"뻬":{"docs":{},"먹":{"docs":{},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"뼈":{"docs":{},"대":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"로":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}},"살":{"docs":{},"펴":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"보":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"새":{"docs":{},"로":{"docs":{},"운":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"세":{"docs":{},"요":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"았":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"도":{"docs":{},"록":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}},"볼":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"봅":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"시":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"성":{"docs":{},"공":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.003875968992248062},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0038580246913580245},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.005250875145857643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.004415011037527594}},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.002325581395348837},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0021413276231263384}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}},"질":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"분":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"능":{"docs":{},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"속":{"docs":{},"성":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.008168028004667444},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.005673758865248227},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.005}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.00851063829787234},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}},"은":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137}}},"의":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"처":{"docs":{},"럼":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"이":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"하":{"docs":{},"지":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"기":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625}}},"도":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"가":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}}},"순":{"docs":{},"차":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"서":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"대":{"docs":{},"로":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942}}}},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"는":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"표":{"docs":{},"(":{"docs":{},"b":{"docs":{},"o":{"docs":{},"m":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}},"수":{"docs":{},"한":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"숫":{"docs":{},"자":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.011102299762093577},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0028551034975017845}},"여":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404}}}}},"형":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"만":{"docs":{},"으":{"docs":{},"로":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"큼":{"docs":{},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}},"와":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"/":{"docs":{},"문":{"docs":{},"자":{"docs":{},"열":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"라":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}},"로":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"쉽":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}}}}}}}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"기":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"암":{"docs":{},"시":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"으":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"이":{"docs":{},"며":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"될":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"한":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}},"묵":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}},"어":{"docs":{},"떠":{"docs":{},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}}}},"떤":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.005426356589147287},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0014275517487508922},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0037209302325581397}}},"떻":{"docs":{},"게":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0031376064545047063},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}},"렵":{"docs":{},"지":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}},"느":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"쨋":{"docs":{},"든":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"디":{"docs":{},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"나":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}},"든":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"색":{"docs":{},"함":{"docs":{},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"리":{"docs":{},"석":{"docs":{},"은":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"려":{"docs":{},"울":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"움":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}},"노":{"docs":{},"테":{"docs":{},"이":{"docs":{},"션":{"docs":{},"과":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"을":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}},"얻":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"게":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"었":{"docs":{},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}},"고":{"docs":{},",":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}},"는":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}},"엄":{"docs":{},"격":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0017844396859386152},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"함":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"해":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"청":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"염":{"docs":{},"두":{"docs":{},"에":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"옮":{"docs":{},"기":{"docs":{},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"여":{"docs":{},"기":{"docs":{},"서":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}}}}}},"옳":{"docs":{},"다":{"docs":{},"고":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942}}},"읽":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}},"어":{"docs":{},"볼":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"야":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588}}},"보":{"docs":{},"실":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"세":{"docs":{},"요":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},".":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"거":{"docs":{},"나":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"전":{"docs":{},"용":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0018876828692779614},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"으":{"docs":{},"로":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}},"도":{"docs":{},"록":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"었":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"고":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"으":{"docs":{},"실":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}},"잃":{"docs":{},"어":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"지":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"으":{"docs":{},"키":{"docs":{},"지":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"잡":{"docs":{},"기":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"아":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"두":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"둘":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"낼":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"을":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"는":{"docs":{},"데":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"장":{"docs":{},"기":{"docs":{},"적":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"단":{"docs":{},"점":{"docs":{},")":{"docs":{},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"점":{"docs":{},"을":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"은":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}},"난":{"docs":{},"감":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"애":{"docs":{},"와":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"적":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"은":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0016901408450704226},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"용":{"docs":{},"하":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"기":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}}},"는":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}},"되":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498}}},"지":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"기":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"며":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002962085308056872},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"한":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"된":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"해":{"docs":{},"야":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}},"합":{"docs":{},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"하":{"docs":{},"고":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"다":{"docs":{},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},"절":{"docs":{},"하":{"docs":{},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"게":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"한":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"어":{"docs":{},"야":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"게":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},"기":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"이":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"조":{"docs":{},"금":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"작":{"docs":{},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"절":{"docs":{},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0011267605633802818}}}},"치":{"docs":{},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"건":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"서":{"docs":{},"만":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"과":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"은":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}}},"부":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.005731188759474949},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"의":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"용":{"docs":{},"히":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"합":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}},"으":{"docs":{},"로":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"을":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"이":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},":":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"정":{"docs":{},"은":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"회":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"되":{"docs":{},"어":{"docs":{},"야":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881}}}}}},"하":{"docs":{},"고":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"좀":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"종":{"docs":{},"류":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"와":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"를":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"료":{"docs":{},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"종":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}}},"즐":{"docs":{},"겁":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"겨":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}},"집":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"합":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},"과":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"서":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},"므":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"을":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"어":{"docs":{},"넣":{"docs":{},"어":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"중":{"docs":{},"되":{"docs":{},"어":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}},"철":{"docs":{},"자":{"docs":{},"가":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"저":{"docs":{},"하":{"docs":{},"지":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"체":{"docs":{},"크":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}},"할":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"계":{"docs":{},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"가":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"인":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"으":{"docs":{},"로":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"이":{"docs":{},"닝":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"충":{"docs":{},"분":{"docs":{},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"히":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}}}}},"족":{"docs":{},"시":{"docs":{},"키":{"docs":{},"도":{"docs":{},"록":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"하":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"돌":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}},"은":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"의":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"이":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"하":{"docs":{},"고":{"docs":{},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"며":{"docs":{},",":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"지":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}}},"에":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"트":{"docs":{},"랜":{"docs":{},"스":{"docs":{},"파":{"docs":{},"일":{"docs":{},"러":{"docs":{},"를":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}}},"레":{"docs":{},"이":{"docs":{},"드":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}},"리":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"플":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":3.354820936639118},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}},"가":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"특":{"docs":{},"별":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{},"즉":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}}},"한":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"정":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0022535211267605635},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0013157894736842105},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"징":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"성":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"을":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"은":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}},"화":{"docs":{},"된":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"히":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},",":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"수":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"한":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"화":{"docs":{},"된":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"틀":{"docs":{},"리":{"docs":{},"거":{"docs":{},"나":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"과":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"판":{"docs":{},"결":{"docs":{},"났":{"docs":{},"다":{"docs":{},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}}},"단":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"되":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"별":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.001294139397300795}},"식":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"평":{"docs":{},"범":{"docs":{},"한":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"가":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"되":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"든":{"docs":{},"지":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"할":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}},"핸":{"docs":{},"드":{"docs":{},"북":{"docs":{},"을":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"에":{"docs":{},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"허":{"docs":{},"용":{"docs":{},"할":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"해":{"docs":{},"준":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}}},"주":{"docs":{},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"!":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},":":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"하":{"docs":{},"고":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"만":{"docs":{},",":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"십":{"docs":{},"시":{"docs":{},"오":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}},"되":{"docs":{},"며":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"지":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"만":{"docs":{},",":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"므":{"docs":{},"로":{"docs":{},",":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}},"었":{"docs":{},"기":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"됨":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}}},"된":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}},"했":{"docs":{},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"혜":{"docs":{},"택":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}}},"혹":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"시":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0020798668885191347},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0016638935108153079},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0023858214042263124},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0028585040495474035},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0017844396859386152},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.009040333796940195},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"활":{"docs":{},"성":{"docs":{},"화":{"docs":{},"되":{"docs":{},"면":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"어":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"있":{"docs":{},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"지":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"었":{"docs":{},"을":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}}}},"하":{"docs":{},"여":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409}}},"면":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"려":{"docs":{},"면":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"기":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"해":{"docs":{},"야":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}}}}}},"용":{"docs":{},"할":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"하":{"docs":{},"므":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"여":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"훨":{"docs":{},"씬":{"docs":{"pages/tutorials/Migrating from JavaScript.html":{"ref":"pages/tutorials/Migrating from JavaScript.html","tf":0.0005633802816901409},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.005649717514124294}}}},")":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},";":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376}}},"_":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588}},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}}}}}}},"i":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203}}},"p":{"0":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}},"1":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}},"docs":{}},"x":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"y":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"pages/declaration files/Consumption.html":{"ref":"pages/declaration files/Consumption.html","tf":0.011299435028248588}}}}}}}}}}}}}}}}}},"_":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"와":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}},"q":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"u":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}},"l":{"docs":{},"i":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}}},"r":{"docs":{},"k":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},";":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}}}}},"거":{"docs":{},"쳐":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"라":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"치":{"docs":{},"며":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"대":{"docs":{},"한":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"슬":{"docs":{},"러":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"궁":{"docs":{},"금":{"docs":{},"할":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"달":{"docs":{},"리":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},",":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},")":{"docs":{},".":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}},"라":{"docs":{},"집":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"성":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"거":{"docs":{},"나":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"아":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0010706638115631692}}}},"독":{"docs":{},"립":{"docs":{},"형":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}},"적":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}}},"특":{"docs":{},"한":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"되":{"docs":{},"기":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"었":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},"!":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.002508361204013378}}}}}},"는":{"docs":{},"데":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"으":{"docs":{},"니":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"면":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},",":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"므":{"docs":{},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"도":{"docs":{},"록":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"지":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}},"만":{"docs":{},",":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"어":{"docs":{},"있":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"야":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}}},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"며":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"봅":{"docs":{},"시":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}}},"빠":{"docs":{},"르":{"docs":{},"게":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"진":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"른":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"싶":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"지":{"docs":{},"도":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}},"어":{"docs":{},"도":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"으":{"docs":{},"면":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"쓸":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091},"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}},"와":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},"야":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"일":{"docs":{},"드":{"docs":{},"카":{"docs":{},"드":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}},"가":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"는":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}}}}},"치":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"하":{"docs":{},"여":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"증":{"docs":{},"가":{"docs":{},"하":{"docs":{},"고":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}}}},"된":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"한":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"명":{"docs":{},"할":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"분":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}},"찹":{"docs":{},"조":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}}}},"채":{"docs":{},"우":{"docs":{},"세":{"docs":{},"요":{"docs":{},":":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.001199040767386091}}}}}},"워":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"택":{"docs":{},"되":{"docs":{},"면":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}},"하":{"docs":{},"게":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}},"캐":{"docs":{},"시":{"docs":{"pages/tutorials/React & Webpack.html":{"ref":"pages/tutorials/React & Webpack.html","tf":0.002398081534772182}}},"스":{"docs":{},"트":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"(":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},")":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}}}},"를":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"강":{"docs":{},"력":{"docs":{},"한":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"하":{"docs":{},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"화":{"docs":{},"된":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"제":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"기":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"로":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"요":{"docs":{},"되":{"docs":{},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}},"하":{"docs":{},"게":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}}},"한":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}},"건":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},"너":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"뛸":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"뛰":{"docs":{},"기":{"docs":{},"[":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}}}}},"뜁":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}},"전":{"docs":{},"성":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},"에":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"하":{"docs":{},"지":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"과":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},"제":{"docs":{},"를":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"정":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"에":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}},"서":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}},",":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},"은":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.003305785123966942},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017}}},"도":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"이":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}},"과":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"는":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"하":{"docs":{},"다":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"게":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"도":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"한":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"부":{"docs":{},"하":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"권":{"docs":{},"장":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}},"되":{"docs":{},"지":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"하":{"docs":{},"는":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"지":{"docs":{"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}},"한":{"docs":{},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"는":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0018604651162790699}}},"런":{"docs":{},"타":{"docs":{},"임":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0028585040495474035},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.004739336492890996},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},",":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"도":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"도":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"엔":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"시":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}},"멤":{"docs":{},"버":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.007137192704203013},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}},"들":{"docs":{},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"에":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"은":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}}}},"와":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147}}},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0025662959794696323},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.00533175355450237}}},"가":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0028228652081863093},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.007137192704203013},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.003421727972626176},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0017543859649122807},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0066068900424728644},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.00427715996578272},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"에":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0033034450212364322},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.008293838862559242}},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"만":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"이":{"docs":{},"기":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"므":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},",":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"(":{"docs":{},"이":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"만":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},"으":{"docs":{},"로":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"보":{"docs":{},"다":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"일":{"docs":{},"지":{"docs":{},"라":{"docs":{},"도":{"docs":{},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}}}}},"뭘":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}},"까":{"docs":{},"?":{"docs":{},"\"":{"docs":{},"라":{"docs":{},"고":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}},"미":{"docs":{},"치":{"docs":{},"지":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"며":{"docs":{},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"는":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.002086230876216968}},"지":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}},"래":{"docs":{},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"리":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"묘":{"docs":{},"한":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"칩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}},"믿":{"docs":{},"어":{"docs":{},",":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"섞":{"docs":{},"인":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"어":{"docs":{},"서":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252}}}}},"쌍":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"엔":{"docs":{},"티":{"docs":{},"티":{"docs":{},"의":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}},"를":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"지":{"docs":{},"니":{"docs":{},"어":{"docs":{},"링":{"docs":{},"에":{"docs":{},"서":{"docs":{},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}}},"진":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}},"을":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.007246376811594203}}},"의":{"docs":{"pages/Iterators and Generators.html":{"ref":"pages/Iterators and Generators.html","tf":0.0036231884057971015}}}},"트":{"docs":{},"리":{"docs":{},"를":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"에":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"역":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376}},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0008771929824561404},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}},"시":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}},"방":{"docs":{},"향":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}},"영":{"docs":{},"향":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0013908205841446453}},"을":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.001750291715285881},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"\"":{"docs":{},"를":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"리":{"docs":{},"한":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"온":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"전":{"docs":{},"히":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}},"왜":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"냐":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},",":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}},"외":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"에":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}},"도":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"부":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"에":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"서":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"도":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"선":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"로":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"부":{"docs":{},"터":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}},"은":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0031720856463124504},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"닉":{"docs":{},",":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"익":{"docs":{},"숙":{"docs":{},"할":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}},"하":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}},"다":{"docs":{},"면":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},",":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}},"한":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"해":{"docs":{},"지":{"docs":{},"는":{"docs":{},"데":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"져":{"docs":{},"야":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}}},"명":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}},"으":{"docs":{},"로":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}},"임":{"docs":{},"의":{"docs":{},"로":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"의":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"을":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}},"베":{"docs":{},"딩":{"docs":{},",":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"포":{"docs":{},"트":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"와":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"좁":{"docs":{},"혀":{"docs":{},"지":{"docs":{},"면":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}},"집":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"히":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"힙":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"줍":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0015432098765432098},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"시":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"챕":{"docs":{},"터":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"서":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"큰":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}},"따":{"docs":{},"옴":{"docs":{},"표":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124}}}}}},"템":{"docs":{},"플":{"docs":{},"릿":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.004867872044506259}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}},"으":{"docs":{},"로":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"을":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0027816411682892906}}}}}},"현":{"docs":{},"재":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0015503875968992248},"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0014292520247737017},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0028368794326241137},"pages/Integrating with Build Tools.html":{"ref":"pages/Integrating with Build Tools.html","tf":0.00303951367781155},"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}},"의":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"로":{"docs":{},"선":{"docs":{},",":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"서":{"docs":{},"는":{"docs":{},",":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"실":{"docs":{},"적":{"docs":{},"인":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"화":{"docs":{},"살":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"표":{"docs":{"pages/Basic Types.html":{"ref":"pages/Basic Types.html","tf":0.0007751937984496124},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0031376064545047063},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},";":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.013418903150525088}}},"k":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},"w":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"w":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}}}}}}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0014114326040931546}}}}}}},"y":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"o":{"docs":{},"f":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.004067295248659641}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"와":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}}},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}}},"e":{"docs":{},"v":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}},"s":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"]":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"p":{"docs":{},"t":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0010214504596527069}}}}},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"y":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}}},"u":{"docs":{},"m":{"docs":{},"l":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}}}}},"n":{"docs":{},"d":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}},":":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0023790642347343376},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Symbols.html":{"ref":"pages/Symbols.html","tf":0.00411522633744856},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"a":{"docs":{},"t":{"docs":{},"z":{"docs":{},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"n":{"docs":{},"g":{"docs":{},"a":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}}}}}},")":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"d":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}}}}}}}}}}}}}},"[":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"]":{"docs":{},":":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"는":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"로":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"를":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"의":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"o":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},":":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}}},"z":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0015860428231562252},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.006622516556291391}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}}},"o":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0044742729306487695}},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},"e":{"docs":{},"r":{"docs":{},";":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}}},":":{"docs":{"pages/Type Inference.html":{"ref":"pages/Type Inference.html","tf":0.0022371364653243847}}}}},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.0009438414346389807}}},";":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}}}},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}}}},"]":{"docs":{},"+":{"docs":{},"$":{"docs":{},"/":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}}}}}},"a":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}}},"c":{"docs":{},"v":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},"i":{"docs":{},"p":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0017041581458759373}},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},")":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00408997955010225},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}},".":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},".":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}},"z":{"docs":{},"i":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},";":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"s":{"docs":{},".":{"docs":{},"t":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}}}}}}}}}}}}}},"를":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"h":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}},"괄":{"docs":{},"호":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}},"가":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"화":{"docs":{},"된":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"깊":{"docs":{},"게":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588}}},"이":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"까":{"docs":{},"다":{"docs":{},"로":{"docs":{},"울":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"냅":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"넘":{"docs":{},"어":{"docs":{},"갈":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"선":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"가":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}},",":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}},"오":{"docs":{},"는":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"겨":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}},"주":{"docs":{},"지":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"는":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}},"면":{"docs":{},",":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}},"줄":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"지":{"docs":{},"는":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}},"데":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"길":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"기":{"docs":{},"면":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"긴":{"docs":{},"다":{"docs":{},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}},"네":{"docs":{},"임":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}},"스":{"docs":{},"페":{"docs":{},"이":{"docs":{},"스":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":10.01123595505618},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.006745362563237774},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.006843455945252352},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.013245033112582781}},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"는":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.006745362563237774},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0013633265167007499},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0040858018386108275},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.008431703204047217},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.0051325919589392645},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0035335689045936395},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}},"에":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}},"서":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"만":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"와":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":5.006745362563238},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}},"는":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"화":{"docs":{},"된":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"가":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"도":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}},"의":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}},"(":{"docs":{},"타":{"docs":{},"입":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"라":{"docs":{},"는":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}}}}},"이":{"docs":{},"밍":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"티":{"docs":{},"브":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.002325581395348837}}}}}},"놀":{"docs":{},"라":{"docs":{},"운":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"란":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"랐":{"docs":{},"더":{"docs":{},"라":{"docs":{},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"랍":{"docs":{},"게":{"docs":{},"도":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"답":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"던":{"docs":{},"질":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}},"둡":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"떠":{"docs":{},"올":{"docs":{},"려":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"뛸":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"뜻":{"docs":{},"인":{"docs":{},"지":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},"이":{"docs":{},"고":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}},"렉":{"docs":{},"시":{"docs":{},"컬":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"막":{"docs":{},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"는":{"docs":{},"데":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"대":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"지":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"머":{"docs":{},"뭇":{"docs":{},"거":{"docs":{},"릴":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"멈":{"docs":{},"추":{"docs":{},"고":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"밀":{"docs":{},"리":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}},"접":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"본":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}},"인":{"docs":{},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"에":{"docs":{},"게":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"문":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},"을":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},"서":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"질":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"론":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}}},"블":{"docs":{},"록":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.004575707154742097},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"과":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"까":{"docs":{},"지":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"으":{"docs":{},"로":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0012479201331114808}}},"은":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.002207505518763797}}}},"랙":{"docs":{},"박":{"docs":{},"스":{"docs":{},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}}}},"쉐":{"docs":{},"도":{"docs":{},"잉":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"써":{"docs":{},"왔":{"docs":{},"던":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"드":{"docs":{},"파":{"docs":{},"티":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017}}}},"양":{"docs":{},"날":{"docs":{},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"식":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625}},"을":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"에":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"질":{"docs":{},"의":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"얕":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"얼":{"docs":{},"마":{"docs":{},"나":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"왼":{"docs":{},"쪽":{"docs":{},"에":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0011092623405435386}},"서":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.0008319467554076539}}}}}},"잇":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}},"잠":{"docs":{},"시":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"좌":{"docs":{},"절":{"docs":{},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"질":{"docs":{},"문":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},"처":{"docs":{},"럼":{"docs":{},",":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"해":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"은":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"할":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"을":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"의":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"짧":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0027739251040221915}}},"아":{"docs":{},"진":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"게":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"캡":{"docs":{},"처":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"된":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}},"(":{"docs":{},"c":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},")":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}}}}}},"할":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"하":{"docs":{},"고":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"함":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}},"쳐":{"docs":{},"되":{"docs":{},"면":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"된":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"링":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}},"에":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"의":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"하":{"docs":{},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"했":{"docs":{},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"콜":{"docs":{},"론":{"docs":{},"은":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"백":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.001344688480502017},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}},"에":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.004160887656033287}},"서":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0023148148148148147},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"은":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}},"의":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.005547850208044383}}},"이":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}},"팀":{"docs":{},"원":{"docs":{},"들":{"docs":{},"과":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"혼":{"docs":{},"동":{"docs":{},"하":{"docs":{},"면":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"지":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"과":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}},"란":{"docs":{},"스":{"docs":{},"러":{"docs":{},"워":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"지":{"docs":{},"기":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}},"움":{"docs":{},"은":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"럽":{"docs":{},"게":{"docs":{},"도":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"고":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"자":{"docs":{},"만":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}},"합":{"docs":{},"(":{"docs":{},"m":{"docs":{},"i":{"docs":{},"x":{"docs":{},")":{"docs":{},"할":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}}}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Mixins.html":{"ref":"pages/Mixins.html","tf":0.0028735632183908046}}}}}}}},"흐":{"docs":{},"름":{"docs":{},"을":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"흘":{"docs":{},"러":{"docs":{},"나":{"docs":{},"오":{"docs":{},"는":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}}},"힘":{"docs":{},"듭":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Variable Declarations.html":{"ref":"pages/Variable Declarations.html","tf":0.00041597337770382697}}}}}},"들":{"docs":{},"어":{"docs":{},"지":{"docs":{},"는":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"게":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}},"?":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.005361434645960436},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0030643513789581204},"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957},"pages/tsconfig.json.html":{"ref":"pages/tsconfig.json.html","tf":0.0014184397163120568},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"를":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"?":{"docs":{},"?":{"docs":{},"?":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}}},"겁":{"docs":{},"니":{"docs":{},"다":{"docs":{},":":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},".":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"게":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"다":{"docs":{},"가":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"시":{"docs":{},"물":{"docs":{},"에":{"docs":{},"서":{"docs":{},"는":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}}}},"괜":{"docs":{},"찮":{"docs":{},"다":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},"!":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"을":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"납":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"넓":{"docs":{},"은":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"똑":{"docs":{},"같":{"docs":{},"이":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"색":{"docs":{},"인":{"docs":{},"화":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},"되":{"docs":{},"면":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}}}}}}}}}}}},"(":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}}}},"상":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"얘":{"docs":{},"기":{"docs":{},"할":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}},"하":{"docs":{},"지":{"docs":{},"만":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"짓":{"docs":{},"는":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"밟":{"docs":{},"지":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"쪼":{"docs":{},"갤":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702}}}},"핵":{"docs":{},"심":{"docs":{"pages/Interfaces.html":{"ref":"pages/Interfaces.html","tf":0.0004385964912280702},"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"#":{"1":{"2":{"3":{"2":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"docs":{}},"docs":{}},"4":{"0":{"8":{"0":{"docs":{},"을":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"5":{"7":{"7":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}},"docs":{}},"docs":{}},"docs":{}},"3":{"2":{"9":{"6":{"4":{"docs":{},"를":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0030643513789581204},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0027906976744186047}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"{":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"}":{"docs":{},"와":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}},";":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}}}}}}}},"격":{"docs":{},"리":{"docs":{},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"길":{"docs":{},"이":{"docs":{},"를":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.001415762151958471},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"와":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}},"덧":{"docs":{},"붙":{"docs":{},"이":{"docs":{},"는":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}}}},"릴":{"docs":{},"리":{"docs":{},"즈":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}},"스":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}}}},"왔":{"docs":{},"는":{"docs":{},"지":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"기":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"쪽":{"docs":{},"도":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}},"에":{"docs":{},"서":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034}}}},"의":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"으":{"docs":{},"로":{"docs":{},"든":{"docs":{},")":{"docs":{},"에":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}}}},"측":{"docs":{},"면":{"docs":{},"과":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"이":{"docs":{"pages/Classes.html":{"ref":"pages/Classes.html","tf":0.00047192071731949034},"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},".":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"에":{"docs":{},"서":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"만":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"(":{"docs":{},"생":{"docs":{},"성":{"docs":{},"자":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"을":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}},"에":{"docs":{},"서":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}},"%":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0022411474675033617},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}},",":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}},"가":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}}}},"남":{"docs":{},"깁":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"은":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"겨":{"docs":{},"놓":{"docs":{},"겠":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}}}}}},"아":{"docs":{},"있":{"docs":{},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"놓":{"docs":{},"을":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"됐":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}}},"둔":{"docs":{},"다":{"docs":{},"면":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"벗":{"docs":{},"어":{"docs":{},"나":{"docs":{},"는":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}},"겨":{"docs":{},"진":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"승":{"docs":{},"인":{"docs":{},"하":{"docs":{},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}}}},"악":{"docs":{},"명":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"짚":{"docs":{},"고":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}}},"창":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}},"을":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}},"에":{"docs":{},"서":{"docs":{"pages/Nightly Builds.html":{"ref":"pages/Nightly Builds.html","tf":0.004608294930875576}}}}},"카":{"docs":{},"드":{"docs":{},"가":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237}}},"를":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.0008964589870013447}}}}},"흔":{"docs":{},"한":{"docs":{"pages/Functions.html":{"ref":"pages/Functions.html","tf":0.00044822949350067237},"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.007352941176470588}}},"히":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"<":{"docs":{},">":{"docs":{},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"굉":{"docs":{},"장":{"docs":{},"한":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"꺾":{"docs":{},"쇠":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}},"괄":{"docs":{},"호":{"docs":{},"(":{"docs":{},"<":{"docs":{},">":{"docs":{},")":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}},"에":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}}}}}}}},"낼":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}},"능":{"docs":{},"력":{"docs":{},"을":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"담":{"docs":{},"아":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"운":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"반":{"docs":{},"할":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}},"영":{"docs":{},"체":{"docs":{},"제":{"docs":{},"/":{"docs":{},"파":{"docs":{},"일":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}}}},"에":{"docs":{},"서":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"찍":{"docs":{},"으":{"docs":{},"려":{"docs":{},"면":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"지":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"팩":{"docs":{},"토":{"docs":{},"리":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0029171528588098016},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"를":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0017772511848341231}}},"(":{"docs":{},"j":{"docs":{},"s":{"docs":{},"x":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}}},"가":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0011668611435239206}}},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603},"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"에":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}}}}}}},"효":{"docs":{},"과":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Generics.html":{"ref":"pages/Generics.html","tf":0.0007057163020465773}}}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643},"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}},"율":{"docs":{},"적":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}},"^":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126},"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0040858018386108275}}},"굳":{"docs":{},"이":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"묘":{"docs":{},"사":{"docs":{},"하":{"docs":{},"기":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"묻":{"docs":{},"는":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}},"신":{"docs":{},"경":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}},"중":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"호":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}},"입":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}},"뢰":{"docs":{},"할":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"친":{"docs":{},"숙":{"docs":{},"하":{"docs":{},"게":{"docs":{"pages/Enums.html":{"ref":"pages/Enums.html","tf":0.0007930214115781126}}}}}},"드":{"docs":{},"물":{"docs":{},"지":{"docs":{},"만":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}}}}},"용":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}},"어":{"docs":{},"가":{"docs":{"pages/Type Compatibility.html":{"ref":"pages/Type Compatibility.html","tf":0.0007716049382716049}}},"를":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"도":{"docs":{},"가":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"이":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}}}},"하":{"docs":{},"게":{"docs":{"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.0010515247108307045}}}}}},"겹":{"docs":{},"쳐":{"docs":{},"질":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"귀":{"docs":{},"찮":{"docs":{},"습":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"은":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"균":{"docs":{},"등":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"끌":{"docs":{},"어":{"docs":{},"내":{"docs":{},"려":{"docs":{},"고":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"낼":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}},"널":{"docs":{},"러":{"docs":{},"블":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0007395082270290257}}}},"리":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0010214504596527069}}}},"래":{"docs":{},"핑":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693},"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"벌":{"docs":{},"어":{"docs":{},"질":{"docs":{},"까":{"docs":{},"요":{"docs":{},"?":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}}},"뽑":{"docs":{},"아":{"docs":{},"내":{"docs":{},"는":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"싱":{"docs":{},"글":{"docs":{},"톤":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.0005546311702717693}}}}},"잊":{"docs":{},"어":{"docs":{},"버":{"docs":{},"렸":{"docs":{},"을":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"었":{"docs":{},"다":{"docs":{},"면":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"컨":{"docs":{},"셉":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"들":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}},"텍":{"docs":{},"스":{"docs":{},"트":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}},"에":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}},"서":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}}},"(":{"docs":{},"예":{"docs":{},":":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498}}}}},"가":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"트":{"docs":{},"롤":{"docs":{},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"테":{"docs":{},"이":{"docs":{},"너":{"docs":{},"가":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"텐":{"docs":{},"츠":{"docs":{},"가":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"케":{"docs":{},"이":{"docs":{},"스":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"가":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"들":{"docs":{},"이":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}},"를":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00036975411351451286}}},"에":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}},"쿼":{"docs":{},"리":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}},"와":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}},"처":{"docs":{},"럼":{"docs":{},",":{"docs":{"pages/Advanced Types.html":{"ref":"pages/Advanced Types.html","tf":0.00018487705675725643}}}}}}},"금":{"docs":{},"방":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}},"논":{"docs":{},"리":{"docs":{},"적":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887}},"으":{"docs":{},"로":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747},"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}},"의":{"docs":{},"한":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}}}},"샘":{"docs":{},"플":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749},"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.0020429009193054137}},":":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0006816632583503749}}},"에":{"docs":{},"서":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}}},"워":{"docs":{},"크":{"docs":{},"플":{"docs":{},"로":{"docs":{},"우":{"docs":{},"를":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}}}}},"컬":{"docs":{},"렉":{"docs":{},"션":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.00034083162917518747}}}}},"헬":{"docs":{},"퍼":{"docs":{"pages/Modules.html":{"ref":"pages/Modules.html","tf":0.0010224948875255625},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}},"를":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}},"↥":{"docs":{"pages/Namespaces.html":{"ref":"pages/Namespaces.html","tf":0.007150153217568948},"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.008168028004667444}}},"덕":{"docs":{},"분":{"docs":{},"에":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434},"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"앰":{"docs":{},"비":{"docs":{},"언":{"docs":{},"트":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.003372681281618887}}}}}},"짜":{"docs":{},"증":{"docs":{},"을":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}}}},"향":{"docs":{},"상":{"docs":{},"된":{"docs":{"pages/Namespaces and Modules.html":{"ref":"pages/Namespaces and Modules.html","tf":0.0016863406408094434}}},"이":{"docs":{},"며":{"docs":{},",":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"후":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.001184834123222749}}}},"국":{"docs":{},"제":{"docs":{},"화":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"밑":{"docs":{},"에":{"docs":{},"서":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"봐":{"docs":{},"야":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"뷰":{"docs":{},"는":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}},"씌":{"docs":{},"웁":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}}}},"옆":{"docs":{},"에":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}},")":{"docs":{"pages/declaration files/Publishing.html":{"ref":"pages/declaration files/Publishing.html","tf":0.0026666666666666666}}}}},"으":{"docs":{},"로":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"토":{"docs":{},"큰":{"docs":{},"을":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0004764173415912339}}}}},"툴":{"docs":{},"이":{"docs":{"pages/Module Resolution.html":{"ref":"pages/Module Resolution.html","tf":0.0009528346831824678}}},"을":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"맨":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544},"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471},"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"몫":{"docs":{},"으":{"docs":{},"로":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}}}},"숙":{"docs":{},"제":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.001710863986313088}}},"련":{"docs":{},"된":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}},"액":{"docs":{},"세":{"docs":{},"스":{"docs":{"pages/Declaration Merging.html":{"ref":"pages/Declaration Merging.html","tf":0.000855431993156544}}}}},"삽":{"docs":{},"입":{"docs":{},"하":{"docs":{},"는":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}},"됩":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}}}}}},"흥":{"docs":{},"미":{"docs":{},"롭":{"docs":{},"게":{"docs":{},"도":{"docs":{"pages/JSX.html":{"ref":"pages/JSX.html","tf":0.0005834305717619603}}}}},"로":{"docs":{},"운":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}},"울":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}},"낮":{"docs":{},"은":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.002369668246445498}}}},"첨":{"docs":{},"부":{"docs":{},"할":{"docs":{"pages/Decorators.html":{"ref":"pages/Decorators.html","tf":0.0005924170616113745}}}}},"낳":{"docs":{},"을":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}},"슬":{"docs":{},"래":{"docs":{},"시":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":3.3531680440771345},"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{"pages/Triple-Slash Directives.html":{"ref":"pages/Triple-Slash Directives.html","tf":0.001652892561983471}}}}}}}}}}},"갯":{"docs":{},"수":{"docs":{},"가":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}}},"닫":{"docs":{},"힌":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"됨":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.0007137758743754461}}},"빈":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306},"pages/Utility Types.html":{"ref":"pages/Utility Types.html","tf":0.002103049421661409}},"번":{"docs":{},"할":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"콤":{"docs":{},"마":{"docs":{"pages/Type Checking JavaScript Files.html":{"ref":"pages/Type Checking JavaScript Files.html","tf":0.00035688793718772306}}}},"깔":{"docs":{},"끔":{"docs":{},"하":{"docs":{},"고":{"docs":{"pages/declaration files/Introduction.html":{"ref":"pages/declaration files/Introduction.html","tf":0.003676470588235294}}}}}},"힌":{"docs":{},"트":{"docs":{},"를":{"docs":{"pages/declaration files/Library Structures.html":{"ref":"pages/declaration files/Library Structures.html","tf":0.0006954102920723226}}}}},"갈":{"docs":{},"수":{"docs":{},"록":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}}},"띄":{"docs":{},"울":{"docs":{"pages/declaration files/By Example.html":{"ref":"pages/declaration files/By Example.html","tf":0.0017667844522968198}}}},"박":{"docs":{},"싱":{"docs":{},"된":{"docs":{"pages/declaration files/Do's and Don'ts.html":{"ref":"pages/declaration files/Do's and Don'ts.html","tf":0.0013869625520110957}}}}},"눈":{"docs":{},"치":{"docs":{},"챘":{"docs":{},"을":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}}},"법":{"docs":{},"칙":{"docs":{},"은":{"docs":{"pages/declaration files/Deep Dive.html":{"ref":"pages/declaration files/Deep Dive.html","tf":0.0011037527593818985}}}}},"►":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.03511705685618729}}},"억":{"docs":{},"제":{"docs":{},"합":{"docs":{},"니":{"docs":{},"다":{"docs":{},".":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0016722408026755853}}}}}}}},"헤":{"docs":{},"더":{"docs":{"pages/Compiler Options.html":{"ref":"pages/Compiler Options.html","tf":0.0008361204013377926}}}},"\\":{"docs":{"pages/Project References.html":{"ref":"pages/Project References.html","tf":0.0020429009193054137}}},"쉼":{"docs":{},"표":{"docs":{},"로":{"docs":{"pages/Compiler Options in MSBuild.html":{"ref":"pages/Compiler Options in MSBuild.html","tf":0.0025}}}}},"급":{"docs":{},"격":{"docs":{},"한":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"삶":{"docs":{},"의":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"왓":{"docs":{},"쳐":{"docs":{},"(":{"docs":{},"파":{"docs":{},"일":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"가":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0013953488372093023}}},"와":{"docs":{},"는":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}},"의":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"캄":{"docs":{},"파":{"docs":{},"일":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"큐":{"docs":{},"를":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.0009302325581395349}}}},"훌":{"docs":{},"륭":{"docs":{},"한":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}},"휴":{"docs":{},"리":{"docs":{},"스":{"docs":{},"틱":{"docs":{},"을":{"docs":{"pages/release notes/TypeScript 3.8.html":{"ref":"pages/release notes/TypeScript 3.8.html","tf":0.00046511627906976747}}}}}}}},"length":26506},"corpusTokens":["!(s.length","!==","!array.isarray(arguments[1]))","!를","\"","\"!node_modules/**/*.ts\"]","\"\"","\"\";","\"$$\",","\")","\");","\"*!text\"","\"*\"","\"*\",","\"*\":","\"**/*.spec.ts\"","\"+\":","\",","\",\"","\".\",","\".\"가","\"...\";,","\"../../built/local/tsc.js\",","\"../constants/http\";","\"../converter\";","\"../node_modules/jquery/dist/jquery\"로","\"../src\"","\"../utils\",","\"./api\";","\"./app\";","\"./app.ts\"","\"./app.ts\",","\"./built\",","\"./calculator\";","\"./components/entry\";","\"./components/hello\";","\"./configs/base\",","\"./dist/\",","\"./dist/bundle.js\",","\"./greet\";","\"./index\";","\"./lettersonlyvalidator\";","\"./lib/main.d.ts\"","\"./lib/main.d.ts\",","\"./lib/main.js\",","\"./main.ts\"","\"./map\";","\"./mi","\"./mod\";","\"./mod\"],","\"./model\"","\"./model.ts\",","\"./model.ts\"를","\"./moduleb\"","\"./moduleb\"`는","\"./moduleb\"의","\"./myclass\";","\"./mycomponent\";","\"./myfunc\";","\"./mylargemodule.ts\";","\"./mythings\";","\"./observable\"","\"./observable\";","\"./onetwothree\";","\"./parseintbasedzipcodevalidator\";","\"./programmercalculator\";","\"./shapes\";","\"./some","\"./src\"로","\"./src/**/*\"","\"./src/index.ts\",","\"./src/index.tsx\",","\"./staticzipcodevalidator\";","\"./stringvalidator\";","\"./template\"처럼","\"./tsconfig\",","\"./utilities\";","\"./utilities.js\";","\"./validation\";","\"./xyz.txt!text\";","\"./zipcodevalidator\";","\".\\n\\n\"","\".js\"]","\".ts\",","\".tsx\",","\".tsx\"]","\".web.js\",","\".webpack.js\",","\"/\":","\"/mod\";","\"/node_modules/typescript/lib\"","\"0\"","\"0\",","\"0.1.2\",","\"0.19.24\",","\"001+010=\");","\"1\",","\"1+2*33/11=\");","\"1.0.0","\"1.0.0\",","\"100\"","\"101\"];","\"123\"","\"123\";","\"2\"","\"2\",","\"2.0.0","\"2.2.0\"","\"3\",","\"3.9.0\",","\"4\",","\"5\",","\"5.0.0","\"6\"","\"6\",","\"7\",","\"8\",","\"9\",","\"98052\",","\":","\";","\"=\")","\"@angular/core\";","\"@type\"","\"@typedef\"","\"@types\"","\"@types/browserify\":","\"^0.6.4\",","\"a\"","\"a\");","\"a\",","\"a\";","\"adams\");","\"adams\",","\"alice\",","\"alice\"});","\"allowjs\":","\"ambient\"라고","\"amd\"","\"amd\",","\"amd\"와","\"angl","\"angular2\":","\"angular2/core\"","\"angular2/platform/browser\";","\"aurora\",","\"author\":","\"awesom","\"awesome\",","\"a를","\"b\"","\"b\",","\"bar\"","\"bar\";","\"bar\"].map(funct","\"bar\"].map(i","\"bar,","\"baseurl\":","\"baseurl\"에","\"baseurl\"을","\"baz\")","\"baz\",","\"binder.ts\",","\"black\"});","\"blue\";","\"bob","\"bob\";","\"bob\"];","\"bod","\"boolean\"","\"browserifi","\"browserify\":","\"bundle.js\"","\"c\"","\"c\",","\"c\";","\"canvas\"):","\"cat\",","\"cat\";","\"checker.ts\",","\"circle\":","\"circle\";","\"classic\"","\"clubs\",","\"commandlineparser.ts\",","\"commonjs\"","\"commonjs\",","\"compileonsave\":","\"compileroptions\"","\"compileroptions\":","\"compileroptions\"에","\"contextu","\"core.ts\",","\"crlf\"","\"current","\"cyan\")","\"d\"","\"d\",","\"danielle\",","\"default\";","\"del\":","\"del\"을","\"dependencies\"","\"dependencies\":","\"dependencies\"를","\"dependencies\"에","\"devdependencies\":","\"devdependencies\"가","\"devdependencies\"를","\"diagnosticinformationmap.generated.ts\"","\"diamonds\",","\"diamonds\"],","\"diamonds\"];","\"div\"):","\"doe","\"dog\",","\"dom\"","\"dom\"]을","\"don't\"s)","\"down\",","\"dynamicpriority\"","\"e\",","\"eas","\"emitdecoratormetadata\":","\"emitter.ts\",","\"endpoint\"","\"es2015\"","\"es2015\",","\"es2015\"사용","\"es2015.d\"ts가","\"es2016\",","\"es2017\"","\"es2020\",","\"es3\"","\"es5\"","\"es5\",","\"es6\"","\"es6\",","\"es6\"/\"es2015\",","\"es6\"와","\"es6가","\"esnext\".","\"esnext\".►","\"esnext\"는","\"exclude\"","\"exclude\":","\"exclude\"는","\"exclude\"를","\"exclude\"에","\"excludes\"에","\"experimentaldecorators\":","\"exports\",","\"exports\"],","\"express\"]","\"extends\":","\"f\"];","\"fallbackpolling\":","\"false\"","\"files\"","\"files\":","\"files\"과","\"files\"를","\"files\"목록에","\"files\"에","\"foo\"","\"foo\",","\"foo\".padstart(4);","\"foo\";","\"fred\"];","\"free\"];","\"fs\"`와","\"function\"","\"generated\"가","\"generated/*\"","\"generated/templates/views\"","\"go","\"greeter","\"greeter라는","\"greeting\");","\"gulp\":","\"gulp\"와","\"hamster\"","\"hamster\"]);","\"hearts\",","\"hello","\"hello!\";","\"hello\",","\"hello\"];","\"hello,","\"hey","\"host","\"hot","\"hour\");","\"howdy\";","\"i'll","\"id\"","\"img\"):","\"include\"","\"include\":","\"include\"을","\"input\"):","\"jane","\"jane\",","\"joseph","\"jquery\"","\"jquery\":","\"jquery\";","\"json!*\"","\"json!*\"와","\"json!http://example.com/data.json\";","\"jsx\":","\"kitty\";","\"last\"","\"latest\",","\"left\",","\"legacy/modulea\"],","\"lf\"","\"lib\":","\"lib/mainmodule.js\"","\"library\"","\"loading...\"","\"lodash\",","\"lodash\";","\"lucas\",","\"m\");","\"m.\",","\"mackinzie\");","\"magenta\")","\"main\"","\"main\":","\"main\"의","\"main.ts\",","\"mallory\";","\"mammals\";","\"man","\"matches\"","\"math","\"mayb","\"microsoft.aspnet.iisplatformhandler\":","\"microsoft.aspnet.server.kestrel\":","\"microsoft.aspnet.staticfiles\":","\"module\"","\"module\":","\"modulea\"","\"modulea\"같은","\"modulea의","\"moduleb\"","\"moduleb\"는","\"moduleb\"의","\"moduleb\"처럼","\"modulename\";","\"moduleresolution\":","\"moment\";","\"mystring\"를","\"name\"","\"name\":","\"namespac","\"new","\"next","\"next\"","\"node\"","\"node\",","\"node.js에서","\"node_modules\",","\"node_modules/jquery/dist/jquery.slim.min.js\"로","\"noemitonerror\":","\"noimplicitany\"","\"noimplicitany\":","\"noisy\"","\"nomaplicitany\"가","\"none\",","\"number\"","\"number\")","\"number\",","\"number\";","\"number\"를","\"object\"","\"object\")","\"object\";","\"oh","\"option","\"outdir\":","\"outfile\":","\"output.js\"","\"output.js\")","\"override\";","\"padding\"을","\"parser.ts\",","\"path\"","\"path\":","\"paths\"","\"paths\":","\"paths\"가","\"paths\"를","\"plunkbat\"","\"pre\",","\"prepend\":","\"preserve\"","\"preserve\".","\"preserveconstenums\":","\"privat","\"production\",","\"program.ts\",","\"property\";","\"react","\"react\"","\"react\",","\"react\":","\"react\";","\"react\"나","\"react\"를","\"react\"와","\"react.createelement\"","\"reactdom\"","\"rectangle\":","\"rectangle\";","\"red\"","\"red\",","\"red\";","\"references\":","\"reflect","\"removecomments\":","\"rich\"","\"rich\",","\"rich\"를","\"right\",","\"rootdirs\":","\"rootdirs\"는","\"rootdirs\"를","\"rory\";","\"rxjs\":","\"sales\");","\"samuel\",","\"scanner.ts\",","\"seattle\"","\"seattle\";","\"seattle\"});","\"size","\"smith\"","\"smith\")","\"solution\"","\"some","\"somemodule\"","\"somemodule\";","\"sourc","\"sourcemap\":","\"spades\",","\"span\"):","\"species\"","\"spicy\",","\"square\":","\"square\";","\"sr.\");","\"src/#{locale}\"","\"src/**/*\"","\"src/de\",","\"src/greet.ts\"","\"src/main.ts\"","\"src/main.ts\",","\"src/views\",","\"src/zh\",","\"strict","\"strictnullchecks\":","\"string\"","\"string\")","\"string\",","\"string\";","\"subparts\"","\"supplemental.ts\"","\"symbol\"이여야","\"sys.ts\",","\"system\"","\"system\",","\"system\"만","\"systemjs\":","\"t","\"target\":","\"test\"));","\"thi","\"thing\";","\"this\"","\"triangle\"의","\"true\"","\"tsc.ts\",","\"typename\"","\"typename\"이","\"typeroots\"","\"types\"","\"types\":","\"types\"라는","\"types\"와","\"types.ts\",","\"typescript\"","\"typescript\");","\"typescript\":","\"typescript\";","\"typescript.tsdk\":","\"typescript_tsdk\":","\"typings\"","\"umd\",","\"undefined\"","\"uneasy\");","\"uneasy\"는","\"up\",","\"updatepart\"","\"url\"","\"url\";","\"url\"을","\"use","\"usefsevents\",","\"user\"","\"user\");","\"utf8\"","\"utilities.ts\",","\"value\"","\"vandelay","\"version\":","\"watchdirectory\":","\"watchfile\":","\"watchoptions\":","\"white\")","\"white\",","\"will","\"will\",","\"world\";","\"yellow\")","\"yes\"","\"yes\",","\"zone.js\":","\"很高兴认识你\"","\"您好吗\",","\"가상\"","\"가상\"디렉터리","\"강한\"","\"건전\"하지","\"구조적","\"날","\"다른","\"대상","\"더","\"덕","\"리터럴","\"문맥상","\"발견\"할","\"배포\"되는","\"브라우저에서","\"빠르고","\"사전\"","\"선언","\"성공\"","\"숨겨진","\"싱글톤","\"아마도\"","\"약한","\"이름","\"인덱스로\"","\"전달하는\"","\"제너릭","\"존재\"하지만,","\"직렬화\"를","\"최상위","\"최적","\"추가\"","\"프로젝트\"로","\"피하는\"","\"해결","\"호환\"","\"환경\"을","#","#1232","#14080을","#2577","#32964를","#foo","#foo;","#name:","#sidelength:","#{locale}와","$","$(\"button.continue\").html(","$(()","$:","$;","${","${compiler}","${compiler}`);","${distanceinmeters}m.`);","${framework}!`;","${maxbase}","${name}.`);","${name}`;","${p.name}...`);","${this.#name}!`);","${this.department}.`;","${this.name}","${validate(s)","$나","$와","%","%,","%s\")","%s\")가","&","&&","&,","'","'!=='","'\"eas","'\"uneasy\"'","'#ff00ff'","'#foo'","'#foo'는","'#name'은","'${","'${char}'`);","'${padding}'.`);","'';","'(src:","'*'","'*'은","'.","'.',","'./#{locale}/messages'를","'./foo';","'./lib/typescript.d.ts'","'./lib/typescript.d.ts'가","'./template1')","'./view2')","'./zh/messages'로","'.js'","'.ts'","'.ts'와","'.tsx'","'.tsx'를","'0'","'1'과","'10'","'10'을","'100'","'11'을","'2'","'20'","'3'이","'5'가","'@return'","'@returns'과","'[string,","'a'","'a'를","'about'","'animal'","'animal'과","'any'","'args'를","'awesom","'b'","'b';","'b'가","'b'는","'boolean'.","'c'","'c'.","'camry',","'cats'를","'cjs',","'clean","'clean'작업도","'clean'작업이","'clear","'clor'","'color'?","'colour'","'component'","'contact'","'contact';","'copi","'d'에","'debug';","'default'","'default'...","'default'로","'define'.","'delet","'dictionary'에","'e'는","'e1'","'e2'","'employee'은","'error'","'es5'보다","'fly'에","'folder1/file2'","'folder1/file2':","'folder2/file3')","'folder2/file3':","'foo!'에","'foo'","'foo'.과","'foo'는","'foo'만","'foo'의","'generated/*'","'green'이","'hello';","'helloprops'는","'home'","'image'.","'info'","'john","'js'","'let'에","'m'","'manufacturer'","'manufacturer');","'model'","'model']);","'modulea'가","'modulea와","'moduleb.","'mycomponent'의","'name'은","'new","'new'","'node_modules'","'node_modules/angular2/bundles/angular2","'node_modules/rxjs/bundles/rx.js']","'node_modules/systemjs/dist/system.src.js',","'node_modules/typescript.d.ts'","'node_modules/typescript.ts'","'node_modules/typescript.tsx'","'node_modules/typescript/lib/typescript.d.ts'","'node_modules/typescript/lib/typescript.d.ts'.","'node_modules/typescript/lib/typescript.d.ts'로","'node_modules/typescript/lib/typescript.d.ts'를","'node_modules/typescript/package.json'.","'nodej","'nodejs'.","'noimplicitany'","'null'은","'null'일","'number","'number'에","'number'에는","'number'이어야","'number[]'","'numberregexp'","'object'에","'ok'","'option1'","'option2';","'organ","'ownersaddress'로","'package.json'","'package.json'은","'padding'은","'padding'이","'parseintbasedzipcodevalidator'","'person'","'person'의","'red';","'regexpbasedzipcodevalidator'","'require'","'require'.와","'rest'","'rootdirs'를","'scripts':","'scripts/**/*.map'],","'scripts/**/*.ts',","'searchfunc'.","'shapekind.circle'","'shapekind.square'","'some","'somelib';","'sourc","'specialtype'이라는","'specialtype1'이라는","'squareconfig'","'squareconfig'.","'src/app.ts'","'src/app.ts'.","'src/node_modules/typescript.d.ts'","'src/node_modules/typescript.ts'","'src/node_modules/typescript.tsx'","'src/node_modules/typescript/package.json'","'state'","'string","'string'","'string'.","'string'에","'string'입니다.","'string[]'타입이","'stringvalidator'","'stuff'","'stuff'는","'substring'","'swim'과","'t","'target'","'target'과","'thi","'this'","'this'를","'this.#foo'","'this.foo'","'throw","'tofixed'는","'toyota',","'tsconfig.json'안에","'tsconfig.json'의","'typeof'","'types'","'typesciprt'","'typescript'","'typescript'는","'u","'undefined'","'undefined'는","'undefined'이","'unknown');","'unknown']);","'unknown'은","'unknown'이","'value'","'warn'","'with'","'x'를","'year'","'year');","'year')의","'year'])","'year'에","'year'와","'zipcodevalidator'","'zipcodevalidator.ts'","'{bar?:","'{foo?:","'내부","'네임스페이스","'때에","'버리는'","'상위'","'선언","'안에","'화살표","(","(!(valu","(!i)","(!somebody)","(\")나","(\"do\"","(\"main\"","(\"modulea의","(\"name\")","(\"swim\"","(\"ts.transpilemodule\"과","(\"types\"","(#)","(#메타데이터","(')를","('any'로","('any'와","('manufacturer'","(()","((e:","((pet","()","(...)","(...arg:","(...args:","(.d.ts)","(.j","(.js,","(.net","(.ts,","(.ts,.d.t","(0.02","(0.05","(0.13","(1)과","(17)에서","(2)는","(3rd","(4)","(7)에서","(9)와","(@","(@configurable)의","(@required)의","(@sealed)의","(`","(a","(a:","(abstract","(accessor","(accessors)","(ad","(add","(addit","(advanc","(age","(aliases)","(allowj","(ambient","(amd),","(any,","(arg:","(arguments.length","(array","(array)","(attribut","(b","(b)","(b:","(base","(basevalue:","(basic","(basic)","(best","(bi","(billion","(block","(boolean)","(build","(built","(c","(call","(callback","(casts)","(char","(children","(class","(classes)","(classes,","(classic)","(co","(code","(colornam","(command","(common","(commonj","(commonjs),","(compar","(compil","(compileroptions,files,includ","(comput","(condit","(condition)","(config.clor)","(config.color)","(config.width)","(configur","(const","(constraint)","(construct","(constructor","(const가","(consum","(consuming)","(contextu","(control을","(creat","(ctrl","(data:","(debug)","(decor","(decorators)","(deep","(default","(definit","(depend","(dependencies)","(destructuring)","(differ","(digit","(disallow","(discrimin","(distribut","(do","(document.getelementbyid(\"compiler\")","(document.getelementbyid(\"framework\")","(done:","(downloading)","(dynam","(e","(e)","(e.g.","(e:","(earli","(eas","(ecmascript","(element:","(embed","(employee.fullname)","(enum","(enum)","(enums)","(err)","(err,","(errors)","(es2015,","(es2020","(es6)","(exampl","(example)","(excess","(exhaust","(explicitli","(export","(extend","(f)","(factori","(factory)","(fc)","(find","(first","(first.hasownproperty(prop))","(firstname:","(fname:","(foo","(footnotes)","(foo를","(from","(function","(function)","(f∘g)(x)의","(gener","(generics)","(get","(global","(greeting)","(guidanc","(hello","(heterogen","(homomorphic)","(hour:","(how","(hybrid","(i)","(i.e.","(identifi","(if","(implement","(import","(import를","(in","(includ","(index","(index.j","(infer","(inheritance)","(initi","(input)","(instal","(instanceof","(integr","(interfac","(interfaces)","(interfaces))","(intersect","(intrins","(introduction)","(isfish(pet))","(isnumber(padding))","(isstring(padding))","(iterables)","(javascript)","(javascript에는","(jsdoc","(key","(lastname)","(lay","(let","(librari","(mac)","(map","(may","(merg","(metadata)","(method","(microsoft.typescript.targets,","(minim","(mod_1_1)","(modul","(modular","(more","(move","(multi","(n)","(n:","(naked)","(name","(namespac","(namespaces)","(namespacing)","(needless","(needzipvalidation)","(newnam","(no","(node)","(node.j","(node.js)를","(note:","(null,","(nullabl","(nullish","(num","(number","(number)","(number)로","(number)를","(number를","(numer","(object","(object)","(object['42'])나","(object[42])를","(option","(options.prop4","(ordering)","(organ","(otherwis","(our","(outdir와","(overload","(overloads)","(overview)","(packag","(paramet","(parameterindex","(path","(pattern","(pet","(pet.fly)","(pet.swim)","(pitfal","(point.i","(point.x","(polymorph","(predefin","(preprocess","(preserv","(prevent","(privat","(programmercalculator.digits.indexof(digit)","(prop:","(properti","(props)","(props:","(public","(public,","(publish","(put","(re","(react","(readonli","(red","(rel","(require,","(requiredparameters)","(require을","(rest","(result","(return","(reusabl","(revers","(rhino","(root,","(run","(s)","(s.kind)","(s:","(sample:","(scope","(searching)","(second.hasownproperty(prop))","(sections)","(see","(selector:","(sequenti","(set","(shorthand","(shouldinitialize)","(simpl","(sn","(somevalu","(somevalue).length;","(source:","(split","(spread)","(start","(start:","(static","(strict","(string","(string)","(string)로","(structur","(subtyp","(support","(tabl","(target","(target)","(target,","(target:","(template)","(templates)","(test","(test)","(the","(thename:","(thi","(thing","(this.greeting)","(this.operator)","(this:","(too","(top","(trace","(trade","(true)","(tsc","(tsc.exe,","(tupl","(tuple)","(type","(typeof","(types)","(typescript","(umd","(umd나","(understand","(union","(unix","(unspecifi","(updat","(us):","(use","(user","(v","(valid","(validator.isacceptable(\"...\"))","(valu","(value:","(values)","(var","(variabl","(virtual","(weed","(well","(whi","(which","(wildcard","(work","(write","(x","(x,","(x.isacceptable(\"...\"))","(x86)\\msbuild\\microsoft\\visualstudio\\v$(visualstudioversion)\\typescript\\microsoft.typescript.target","(x:","(x?,","(x와","(y","(y:","(zipcodevalidator:","({","({name:","(|)로","(간단한","(값과","(공통","(그냥","(그리고","(기본값),","(기본값)을","(기본값은","(기본적으로","(네임스페이스","(다른","(디렉토리","(디폴트):","(또는","(만약","(맨","(명확한","(모듈","(모듈로","(밀리초)","(변수,","(스크립트는","(아래","(아래를","(여기서는","(역","(예","(예.","(예:","(예를","(예시.","(예외적으로","(오버로딩된","(위를","(윈도우)","(유닉스).\"","(이","(이는","(인용)","(인코딩","(인터페이스)","(전역","(즉","(즉,","(즉시","(클래스의","(클로저","(타입","(타입은","(특정","(프로그래머에게는)","(하나의","(하지만","(함수형","(혹은","(확장",")",");",")를","*","**","**/","**마세요**!","*,","*/","*/)","*/,","*/];","*=","*code*","*declaration*","*또한*","*만","*참고:","+","+,","+=",",",".","..","...","...)","....","...;","...bc]","...c","...d]","...data,","...default","...defaults,","...fieldstoupd","...first,","...method","...nums:","...passthrough","...rest:","...rest]","...restofname:","...second,","...todo,","...로","../.","../../node_modules/@types/","../node_modules/@types/,","./","./#{locale}/messages를","./#{locale}/messages와","./de/messag","./dist/main.js를","./node_modules/@types/,","./node_modules/@types/express만","./node_modules/@types/lodash","./node_modules/@types/node,","./node_modules/@types의","./typings의","./zh/messages,","./zh/messages는",".add(\"main.ts\")",".add(1)",".alert(...)",".bundle()",".catch(",".currentvalue();",".d.t",".d.ts)",".d.ts)를",".d.ts,",".d.ts.map,",".d.ts를",".d.ts에",".entry(\"entry.ts\")",".es,",".es6",".h",".j",".js,",".js.pipe(gulp.dest(\"dist\"));",".json",".jsx",".jsx).",".jsx)도",".js로",".js와",".js파일로",".js파일이",".length",".length가",".length를",".length에",".log(...)",".map",".multiply(5)",".pipe(buffer())",".pipe(gulp.dest(\"dist\"));",".pipe(gulp.dest('dist'));",".pipe(process.stdout);",".pipe(source('bundle.js'))",".pipe(sourcemaps.init({loadmaps:",".pipe(sourcemaps.write('./'))",".pipe(ts({",".pipe(tsproject())",".pipe(uglify())",".plugin(\"tsify\",",".plugin(tsify)",".run(funct",".sin()",".t",".transform('babelify',",".ts,",".ts/.tsx",".tsx",".tsx)",".tsx로",".tsx를",".ts로",".ts와",".ts의",".ts파일을",".use(typescript())",".vscode/settings.json","/","/*","/*!로","/**","/,","//","///","////////////////////////////////////////","//출력","/\\.js$/,","/\\.ts(x?)$/,","/\\.tsx?$/,","/^[0","/^[a","/collections/generic/","/generated/templates/views를","/generated/로","/moduleb.d.t","/moduleb.t","/node_modules/,","/node_modules/@types/moduleb.d.t","/node_modules/moduleb.d.t","/node_modules/moduleb.j","/node_modules/moduleb.t","/node_modules/moduleb.tsx","/node_modules/moduleb/index.d.t","/node_modules/moduleb/index.j","/node_modules/moduleb/index.t","/node_modules/moduleb/index.tsx","/node_modules/moduleb/package.json","/node_modules/typescript/lib","/root/moduleb.d.t","/root/moduleb.t","/root/node_modules/@types/moduleb.d.t","/root/node_modules/moduleb.d.t","/root/node_modules/moduleb.j","/root/node_modules/moduleb.t","/root/node_modules/moduleb.tsx","/root/node_modules/moduleb/index.d.t","/root/node_modules/moduleb/index.j","/root/node_modules/moduleb/index.t","/root/node_modules/moduleb/index.tsx","/root/node_modules/moduleb/package.json","/root/src/folder/a.ts안에","/root/src/folder/moduleb.d.t","/root/src/folder/moduleb.t","/root/src/modulea.js가","/root/src/modulea.js에","/root/src/modulea.t","/root/src/modulea.ts안에","/root/src/moduleb","/root/src/moduleb.d.t","/root/src/moduleb.js라는","/root/src/moduleb.t","/root/src/moduleb.tsx","/root/src/moduleb/index.d.t","/root/src/moduleb/index.t","/root/src/moduleb/index.tsx","/root/src/moduleb/lib/mainmodule.js를","/root/src/moduleb/package.json","/root/src/moduleb/package.json파일을","/root/src/node_modules/@types/moduleb.d.t","/root/src/node_modules/moduleb.d.t","/root/src/node_modules/moduleb.j","/root/src/node_modules/moduleb.t","/root/src/node_modules/moduleb.tsx","/root/src/node_modules/moduleb/index.d.t","/root/src/node_modules/moduleb/index.j","/root/src/node_modules/moduleb/index.t","/root/src/node_modules/moduleb/index.tsx","/root/src/node_modules/moduleb/package.json","/src/converter.t","/src/units.t","/src/view와","/test/convert","/test/unit","/tsconfig.json","/undefined라고","/usr/local/lib/node_modules/typescript/lib","/으로","0","0)","0);","0,","0.16beta","0.5","0;","0]","0b1010;","0o744;","0xf00d;","0});","0};","0개","0대신","0부터","0으로","1","1)","1).join(\"","1);","1,","1.1","1.1.2:","1.36","1.7","1.7).이렇게","1.8","1.8.4","10","10,","100","100)","100,","1000);","1000}","1001","1001)","100;","100};","101","10;","10];","10am.\");","10}));","10};","10을","10이","10이라는","10입니다.","10자가","10진수","11","11;","12","12,","123;","12;","13","13);","13;","13};","14","14초에서","16진수,","17);","1;","1x","1개","1부터","1씩","1이어야","1초로","1초에","2","2)","2));","2);","2,","2.0","2.0에서는","2.2","2.3","2.3부터,","2.7","2.8","2.8에서","20","20,","200;","2013","2013:","2014","2015","2015:","2015를","2015부터","2015부터,","2015에","2015에서","2015와","2017과","2017이","2020","20;","2261","26","2808","2824","2;","2]);","2],","2];","2})}","2};","2개의","2단계","2라는","2와","2의","2인","2진수,","3","3);","3,","3.0","3.0,","3.7","3.8","3.8는","3.8에서,","3.8에서는","3.8은","32);","32)안에","34m.","37;","3;","3];","3rd","3});","3};","3개의","3는","3에","3으로의","4","4);","4,","4000","45)","4;","4]);","4];","4}","4가지","5","5)","5);","5,","5.0;","500);","52);","5;","5;에서는","5];","5]라는","5m.","5x","5분","6","6,","6;","6];","6로도","7","7,","8","8;","8진수","9","9;","9]+$/;",":",":(",":)",":lib",";","<>로","=","==","===","========","=>","=를","=와",">",">=",">>,",">>>,","?","????","?를","@arg","@argument)","@augment","@augments)","@augments를","@callback","@callback,","@callback은","@class","@classdecor","@component({","@configur","@configurable(false)","@constructor","@constructor)","@constructor를","@enum","@enumer","@enumerable(false)","@enumerable(false)데코레이터는","@enum은","@express","@extend","@extends는","@f","@f()","@format","@format(\"hello,","@g","@g()","@intern","@jsx","@param","@param과","@param은","@privat","@private은","@prop","@properti","@protected는","@protected입니다.","@public,","@public은","@readonli","@reflect.metadata","@reflect.metadata(\"design:type\",","@requir","@return","@return)","@seal","@sealed가","@sealed를","@t","@templat","@thi","@this를","@type","@typedef","@typedef,","@typedef를","@typedef와","@types)","@types,","@types/","@types/browserifi","@types/lodash","@types/mylib","@types/node/index.d.ts에","@types/react","@types안에","@types에","@type{array.}","@type{array}","@type과","@type은","@type의","@valid","[","[\"\",","[\"**/*.ts\",","[\"./typings\"]","[\".ts\",","[\"0\",","[\"alice\",","[\"bob\",","[\"copi","[\"es2015\",","[\"hearts\",","[\"hello\",","[\"node\",","[\"node_modules/jquery/dist/jquery\"]","[\"require\",","[\"ts\"]);","['.ts']","['copyhtml'],","['es2015'],","['lib'],","['manufacturer',","['model',","['node_modules/angular2/bundles/angular2.js',","['scripts/**/*.js',","['somelib'],","['src/*.html']","['src/main.ts'],","['year',","[(string","[,","[0","[0,","[1,","[10,","[10:34:20]","[10:34:21]","[10:35:22]","[10:35:24]","[1]","[2]","[3,","[4,","[7,","[]","[],","[];","[]로","[]를","[a,","[a]","[directions.up,","[disposable,","[elemname:","[first,","[first]","[getclassnamesymbol](){","[index:","[index]","[k","[key:","[new","[number,","[options.prop4]","[options.prop5=42]","[p","[p3]","[p4=\"test\"]","[prop4]","[prop5=42]","[propname:","[s:","[second,","[somebody]","[string,","[string]","[sym]:","[unknown]","[x:","[x:string]:","[{","[노드][#노드","[메타데이터]","[클래식][#클래식","\\","]","],","];","^","_","_.padstart(\"hello","__extends,","__extends와","__rest,","__spread에","_fullname:","_i","_p0:","_p1:","_x:","_y:","`","```","```t","`a`가","`b`","`bind`의","`bob","`export","`foo`","`hello","`hello,","`import","`mi","`name`의","`number`에","`omitthisparameter`을","`square`의","`string`","`this`가","`this`를","`undefined`를","`x`를","`{}`","a):","a++;","a,","a.a","a.b","a.b.c","a.b는","a.ts가","a.ts에","a.y);","a:","a;","a=\"\",","a?:","a[10]","ab(){}","about:","abov","abstract","access","account","accountingdepart","accountingdepartment();","act","actiavat","activat","activatable]);","activatable을","activate()","actual","ad","adams\"","add","add(operand:","add(x,","add(x:","add1:","add:","addclicklistener(onclick:","addclicklistener가","addclicklistener로","addit","additionally,","addtoz(x,","advanc","ag","again,","age:","age?:","agemap[\"daniel\"]","album","album.albumlabel;","albumlabel","alert","alert(\"card:","alertopt","alia","alias):","alias;","aliased(arg:","aliased는","aliases)","aliases))","allow","allowj","allowjs에만","allowjs와","allowsyntheticdefaultimport","allowunreachablecod","allowunreachablecode와","allowunusedlabel","allowunusedlabels로","allvalidators.t","along","alway","alwaysstrict","alwaysstrict,","ambiance:","ambient","amd","amd,","amdmodule.j","amdmodule.t","amd를","amd와","amount","analog","analogclock","analogclock이","angular","angular가","anim","animal(\"cat\").#name;","animal(\"cat\").name;","animal(\"goat\");","animal):","animal,","animal;","animal[]","animalshavemuscl","animalshavemuscles()","animals의","animal과","animal로","animal에","animal에서","animal을","animal의","animal이","animal이라는","animate(dx:","annotations)","anormalfunction()","anormalfunction}","anoth","anothercomponent(prop:","any)","any):","any)를","any,","any;","any[]","any[])","any[]):","any[],","any[]을","anyfunct","anyth","any가","any나","any는","any로","any를","any만","any에서의","any와","any의","any이므로","any임","any입니다.","any입니다:","api","api,","api를","api뿐만","api에","api에서","app","app)","app.t","app.ts는","app.ts에","app.ts의","app.usedefaultfiles();","app.useiisplatformhandler();","app.usestaticfiles();","app`,","appear","appear:","applic","applymixins(derivedctor:","applymixins(smartobject,","area(s:","area:","area도","arg","arg;","argument","argument.\");","arguments)","arguments);","arguments.length","arguments[0];","arguments[1];","arguments[parameterindex]","arguments라는","arg가","arg를","arg의","arr","arr:","array","array#foreach는","array(52),","array(pad","array(this.numspac","array)","array):","array,","array.","array.prototype.concat를","array.prototype.toobserv","array.prototype이나","array:","array;","arraylike;","array와","arrow","asp.net","assert.areequal(converter.celsiustofahrenheit(0),","assertion)으로","assertion)을","assertions)","assertnever(s);","assertnever(x:","assertnever는","assign","assign.extra","assignment)","assumechangesonlyaffectdirectdepencies을","assumechangesonlyaffectdirectdependencies에서는","async","as라는","atom","attempt","auditing\");","augmentation)","automat","await","await\"이라는","await)","await로,","await은","await을","awar","awesom","awkward","a가","a는","a라는","a를","a에","a와","a의","b","b)","b);","b,","b.ts가","b.ts는","b:","b;","b=0","b?:","b?는","b]","babel","babel)에","babel,","babelifi","babelify는","babelify도","babelify를","babelify에","babel과","babel에서","babel은","babel의","bad","badprop","bags\"","bags\"을","bar","bar(1);","bar(1,","bar(a,","bar,","bar.a;","bar/tsconfig.json","bar:","bar;","bar?:","bark()","bark()와","bar가","bar로","bar를","base","base:","basectors.foreach(basector","basectors:","basedir:","baseurl","baseurl과","baseurl로","baseurl에","baseurl을","baseurl의","basic","basiccalcul","basiccalculator(2)","basiccalculator를","baz","baz.d.t","baz.j","bc:","be","bearimy\");","bee","beekeep","beekeeper;","beep\");","befor","beforeall(action:","beginningofline:","behav","behind","below)","benefits)","beta.11\",","beta.2\",","better","between","bigint","bigint,","binary:","bindings,","bird","bird)","bird).fly();","bird).fly)","bird):","bird는","bird를","bivari","bivariance)","blue","blue,","blue}","bobbington`;","bodies)","body가","boolean","boolean)","boolean):","boolean)}","boolean,","boolean;","boolean]","booleanlikeheterogeneousenum","boolean}","boolean}'","boolean은","boolean이","boolean입니다,","boom!","bootstrap(myapp);","both","both.","bothplu","bothplus에","bound","boundari","bower_components,","box","box:","boxed;","boxedarray","boxedarray;","boxedvalu","boxedvalue;","boxed의","br","bracket\"","breakpoint가","breakpoint를","break문을","breed:","broken(name:","browse.","browserifi","browserify()","browserify({","browserify,","browserify가","browserify는","browserify를","browserify에","browserify와","browserify의","buffer","buffer');","buffer와","build","build)","build.","buildlabel","buildlabel(name:","buildlabel.prefix","buildlabel.suffix;","buildname(\"bob\");","buildname(\"bob\",","buildname(\"joseph\",","buildname(firstnam","buildname(firstname:","buildname(undefined,","buildname;","buildnamefun:","builds.","build에는","built","builtd에","bundl","bundle()","bundle);","bundle);을","bundle.j","bundle.js가","bundle.js의","bundle을","button","button.animate(0,","buttonprop","button과","byte","b가","b는","b를","c","c#","c#과","c#에서는","c#의","c#이나","c()","c().#foo);","c().foo);","c();","c()[\"#foo\"]);","c()[\"foo\"]);","c(0);","c(1);","c(10);","c(data)","c):","c,","c.a","c.b","c.count","c.d","c.d;","c.interv","c.prop","c.prototype.initi","c.prototype.method","c.reset();","c.x;","c/c++에","c:","c:\\program","c;","c[getclassnamesymbol]();","c]","cache:","calcul","calculatedistancefromorigin(point:","calculator();","calculator(2);","calculator,","calculator.t","calculator로","calculator를","call","callback:","callbackforlater(e)","callbacks)","called\");","callee가","calls)","can't","captur","capturing)","car","car;","card","card:","card;","cardpick","cardpicker();","cardpicker()의","cards:","card를","card와","caroline\",","carprops:","car는","car에","car의","case","cat","cat):","cat;","catch","catskittyset","caus","caveat","cd","cdn","cdn(content","central","certain","chaining),","chaining를","chang","charset","check","checking\"","checking)","checking)를","checking,","checkj","checkjs를","checks)","chelper()","children:","chinese:","circl","circle,","circle;","citi","city;","city를","city에","ci를","class","class.d.t","class.d.ts를","classdecorator(constructor:t)","classes)","classes,","classic","classic]이고","classnam","class나","class를","clause)","clean:","cleaning.","cli","clickableprop","cli를","clock","clock:","clockconstructor","clockconstructor,","clockconstructor는","clockinterfac","clockinterface;","clockinterface는","clone","clone(animal:","clone.m();","clone.p;","cloner","cloning.","close","closur","closure의","cloud\"","clutter',","cn","coalescing),","code","code\"]","code)","code나","code와","color","color(value:","color.blue;","color.green","color.green;","color.r","color:","color?:","color[2];","colorname:","color나","color대신","color에","color와","colour","colour:","colour로","combin","combinations)","combinations:","commandlin","common","commonj","commonjs,","commonjs/node.j","commonjs/require.js)에","commonjs가","commonjs를","commonjs와","commonjs의","compat","compil","compileonsav","compileonsave를","compiler)","compiler.","compiler:","compiler?)","compiling,","completed:","compon","component)","componentfoo(prop:","components,","components/","composit","composition)","comput","concepts)","condit","config","config.clor;","config.color;","config.width","config.width;","configs/base.json:","configur","configurable(value:","configurationfile을","configure(iapplicationbuild","configure를","conflicts)","console.error(e))","console.error.bind(console));","console.log(\"beep","console.log(\"depart","console.log(\"f():","console.log(\"g():","console.log(\"galloping...\");","console.log(\"gener","console.log(\"half","console.log(\"hello,","console.log(\"hi!\");","console.log(\"oh","console.log(\"roam","console.log(\"slithering...\");","console.log(\"th","console.log(\"thi","console.log(\"tick","console.log('clicked!');","console.log('hello","console.log('hello!');","console.log('woof!","console.log((","console.log(`\"${","console.log(`\"${s}\"","console.log(`${this.name}","console.log(`'${","console.log(`anim","console.log(`hello","console.log(`hello,","console.log(`walk","console.log(a","console.log(a.equals(b));","console.log(a.x","console.log(arg.length);","console.log(buildlabel(\"sam","console.log(colorname);","console.log(data,","console.log(e));","console.log(e);","console.log(e.x","console.log(employee.fullname);","console.log(entry);","console.log(f());","console.log(first);","console.log(fivetohex());","console.log(fourth);","console.log(greeter.greet());","console.log(greeter1.greet());","console.log(greeter2.greet());","console.log(greeting);","console.log(grid1.calculatedistancefromorigin({x:","console.log(grid2.calculatedistancefromorigin({x:","console.log(howard.getelevatorpitch());","console.log(howard.name);","console.log(i);","console.log(instance.chelper());","console.log(instance.dhelper());","console.log(item));","console.log(labeledobj.label);","console.log(moment.format());","console.log(mouseevent.button);","console.log(new","console.log(num);","console.log(obj[sym]);","console.log(pet);","console.log(rest);","console.log(sayhello(\"typescript\"));","console.log(second);","console.log(stringnumeric.add(stringnumeric.zerovalue,","console.log(this.isact","console.log(this.stuff);","console.log(uievent.button);","console.log(x","console.log(x)","console.log(x.count);","console.log(x.startswithhello());","console.log(x[0].substring(1));","console.log(x[1].substring(1));","console.log(x[5].tostring());","console.log(y.reverseandsort());","consolelogg","consolelogger.prototype);","const","const,","constant","constraint","constraints)","constructor","constructor()","constructor(foo:","constructor(greeting:","constructor(h:","constructor(m:","constructor(message:","constructor(name:","constructor(numfeet:","constructor(priv","constructor(protect","constructor(publ","constructor(readonli","constructor(sidelength:","constructor(thename:","constructor(valu","constructor(x:","constructoronly는","constructorparamet","constructorparameters;","constructorunknown의","const가","const는","const를","consumer.t","consumpt","contact:","contain","content:","content;","contents)","context:","continu","contributing.md를","control","control과","control의","convers","convert","copi","copy.","core","core)","core를","correct","correctly.","correspond","count","count:","counter","counter.interv","counter.reset","counter;","creat","create(\"string\");","create(42);","create(c:","create(false);","create(null);","create(o:","create(undefined);","create({","createcardpicker(this:","createcardpicker:","createcardpicker가","createcardpicker에","createclock","createclock(analogclock,","createclock(ctor:","createclock(digitalclock,","createclock의","createelement(\"div\")으로","createelement(tagname:","createelement를","createelement와","creategreeting(s)","createinstance(bee).keeper.hasmask;","createinstance(c:","createinstance(lion).keeper.nametag;","createsquare(config:","createsquare(squareoptions);","createsquare({","createsquare({color:","createsquare를","createsquare안의","createsquare에","createsquare의","createzoo():","crlf","cs","ctor(hour,","current","currenttime:","currentvalu","currentvalue():","currentvalue:","customcomp","czech:","c는","c를","c와","c의","d","d();","d.t","d3","d3.base;","d3.d.t","d3:","d3이라는","d:","d;","d]","dad","dad.nam","data","data:","data?:","date","date();","date)","date):","date;","de","deactivate()","dead","debug","debug:","debugg","decimal:","deck","deck)","deck):","deck.createcardpicker();","deck:","deck을","deck이","declar","declaration)","declaration)을","declarationdir","declarationmap","declarationmap,","declarations)","declarations.d.t","decorators)","deep","default","default)","default:","defaultextension:","defaulthead","defaults안에","default는","default를","default의","defin","define(\"namedmodule\",","define(...)","define(...,","define(...args:","define([\"foo\"],","define([\"libname\"],","define([\"require\",","define,","define.amd)","define에","definitelytyped에서","definitelytyped의","definition\"","del","del(['wwwroot/scripts/**/*']);","delet","deliveri","depart","department();","department.generatereports();","department.printmeeting();","department.printname();","department:","department;","depend","dependencies)","dependencies,","dependencies에","dependency에","dependeni","deprec","desc.data","desc.method","description:","descriptor)","descriptor.configur","descriptor.enumer","descriptor.set","descriptor.set;","descriptor.valu","descriptor.value;","descriptor:","desk',","destructur","destructuring)","detect","determin","dev","devdepend","devdependencies를","develop","devtool:","dhelper()","diagnost","dictionari","dictionary).","dictionary;","dictionary['foo'];","dictionary[42];","diff","diff(one:","diff;","differenti","diff를","digit","digitalclock","direct","direction.up","directions.down,","directions.left,","directions.right]","directori","directories)","disablesizelimit","disk","dispos","disposable,","disposable과","dispose()","dist","dist/","dist/bundle.j","dist/index.html을","dist/main.j","distancefromorigin(point:","dist에서","dist의","dist폴더를","div","dive","dive)","div가","do","do'","doanimalshavemuscl","doanimalshavemuscles()","doc","docs처럼","document","document.body.textcont","document.getelementbyid(\"example\")","document.getelementbyid(divname);","document.queryselector(selector);","document의","doe';","doesn't","dog","dog();","dog):","dog.bark();","dog.move(10);","dog;","dog는","dog은","dollar","dom","dom\":","dom\";","dom\"과는","dom,es5,scripthost","dom,es6,dom.iterable,scripthost","dom.iter","dom을","dom의","dom이","don't","don'ts에","done","donefn)","doubl","down","down,","downleveliter","drop을","dry)","dry:","duo","duo(__dirname)","duration:","duration?:","dx","dx;","dy","dy:","dy;","dynam","dynamicprioritypolling:","e","e)","e.bar","e.bar)","e.foo","e.g.","e.messag","e.message;","e.x는","e.y))","e.y));","e1","e2","e:","each","each:","earth...\");","eas","easing)","easing:","echo","ecmascipt","ecmascript","ecmascript2020은","ecmascript3에서도!","ecmascript의","edge에서","edit","editor","editor,","editors.","effect","effects가","elapsedtim","elapsedtime:","elapsedtime?:","element","element.dataset.mydata","element;","elementattributesproperti","elementchildrenattribut","elementclass","elements)","elementtyp","eleph","elephant(),","elephant,","else문","elt","elt.innertext","emit","emitbom","emitdecoratormetadata","emitdecoratormetadata[1]","emit을","employe","employee(\"bob\");","employee(\"howard\",","employee();","employee.fullnam","employee;","employeenam","employee는","employee라는","employee를","employee의","empti","empty;","empty를","en","enabl","enabled.","end","ended)","endpoint","enforc","enforce:","english","ensur","entir","entri","entries:","entry.t","entry:","enum","enum.a;","enum;","enum[a];","enum[enum[\"a\"]","enumer","enumerable(value:","enumerable)의","enums)","enum과","enum은","enum의","enum입니다.","epithet;","equals(other:","equival","err;","error","error!","error(\"fullnam","error(\"miss","error(\"someth","error(\"unexpect","error(`bas","error(`expect","error(`unsupport","error(message);","error(message:","error,","error:","errors)","errors,","errors.","es","es2015","es2015.collect","es2015.cor","es2015.gener","es2015.iter","es2015.promis","es2015.proxi","es2015.reflect","es2015.symbol","es2015.symbol.wellknown","es2015도","es2015를","es2015에","es2015에는","es2015에서","es2015에서는","es2016","es2016.array.includ","es2017","es2017.object","es2017.sharedmemori","es2017.string으로","es2017.typedarray","es2020","es2020용","es2020을","es3","es3)","es3,","es3를","es3으로","es5","es5,","es5:","es5를","es6","es6:","es6가","es6로도","es6에","es6에서는,","es6의","es7","esnext","esnext.asynciter","esnext.promis","etc.),","evalu","evaluate()","evaluated\");","evaluateoperator(operator:","evaluation)","even","event","event)","event:","event;","eventtarget):","eventtyp","eventtype,","exampl","example)","example:","example;","examples)","examples.","except","exclud","exclude:","exclude;","exclude는","exclude를","exclude와","execute:","exist","exist.","existingrequiredparameters,","existingrequiredparameters.push(parameterindex);","existingrequiredparameters:","exp","exp();","expect","experimentalasyncfunct","experimentaldecor","experimentaldecorators[1]","experimentdecor","explain","explicit","explicitli","explorer가","explorer를","export","export\"가","exports)","exports);","exports,","exports.c","exports.t","exports_1(\"t\",","exports가","exports는","exports도","exports로","exports를","exports에","exports와","export가","export는","export되는","export된","export로","export를","export만","export와","export한","export할","expr","express","express();","express,","expression)를","expression...\"","expressions)","expression은","express는","express와","expr은","expr의","exp로","extend","extend(first:","extend(new","extend)","extend/impl","extends)","extends는","extends를","extends의","extens","extension\",","extensions:","extern","externals:","extract","extract;","e가","f","f()","f():","f();","f(1);","f(1,","f([1,","f([first,","f(condition,","f(e);","f(false);","f(false,","f(g(x))와","f(input:","f(math.random()","f(obj:","f(shouldinitialize:","f(sn:","f(this:","f(true);","f(true,","f(x)","f(x);","f(x:","f({","f({});","f1():","f1(arg:","f1(s:","f1(x:","f12","f2(x:","f5키를","facebook은","factories)","factory(require(\"libname\"));","factory(require,","factory(root.libname);","factory)","factory);","fail()","failed\");","fairli","fallbackpolling:","fallthrough","fals","false,","false;","false];","false와","faq","faster","fc","featur","feedpets(pets)","feet:","fetch(\"...\");","fetcher","few","field","fields)","fieldstoupdate:","file","file'","file)","file,","file.","file1.j","file1.t","file2.j","file2.t","file3.t","file:","filea.t","filea.ts를","filea.ts와","filea.ts의","fileaccess","fileb.ts,","fileb.ts를","fileb.ts만","filec.t","filec.ts를","filecont","filecontent);","filed.ts를","filename:","files)","files).","files,","files.","files:","files].","file을","filter","filter;","final","final\"","final\",","find","finish","first","first)","first)[prop]","first,","first.","first[prop];","first];","firstnam","firstname:","firstname;","firstname에","firstname을","first와","fish","fish).swim","fish).swim();","fish).swim)","fish가","fish는","fish라는","fish로","fish이면,","fivetohex:","fixed(name:","fixedpollinginterval:","flag","flag)","flag,","flags)","flexibl","fli","flower","flow를","fly();","fly를","fn():","fn(myelem);","fn(x.diff);","fn(x:","fn10(p1){}","fn6;","fn7;","fn9(p1)","folder","folder,","folder.","folder1","folder1/file2","folder2","folder2/file3","folders.","following:","foo","foo!.length;","foo()","foo().stuff++;","foo().stuff;","foo();","foo(i","foo(x:","foo,","foo.d.t","foo.d.ts을","foo.dostuff();","foo.j","foo.l.push(\"end\");","foo.l.push(foo.i);","foo.length;","foo.prototype.sayhi","foo.sometyp","foo.somevar.a;","foo/prd.tsconfig.json","foo:","foo;","foo?:","food","food:","fooprop","fooprop)","foo는","foo로","foo의","for)","for..in","for..in은","for..of","for..of,","for..of는","forc","force:","forceconsistentcasinginfilenam","format(formatstring:","format:","formatmetadatakey","formatstr","formatstring);","formatstring.replace(\"%s\",","found","fourth]","fr","framework","framework:","frankwallis/duo","freeze(obj:","french:","frozen","fs","fs.readfilesync(f);","fs.writefilesync(out,","fucntion","fulli","fullnam","fullname():","fullname(newname:","fullname:","fullnamemaxlength","fullnamemaxlength)","fullnamemaxlength);","fullname을","fullname이","function","function()","function(){};","function(exports_1)","function(f)","function(foo)","function(grunt)","function(mouseevent)","function(param1){}","function(pets)","function(point:","function(s)","function(somelib)","function(source:","function(src,","function(src:","function(this:","function(uievent)","function(uievent:","function(x,","function(x:","function(y:","function)","function)과","function)로","function,","function.d.t","function.d.ts.","function.d.ts을","function>;","functionproperti","functionproperties;","functionpropertynam","functionpropertynames;","functions)","functions,","function선언","function을","f가","f와","f의","g","g()","g():","g();","g.alert({","g.log({","galloping...","gener","general,","generated/folder2/file3","generated/templ","generatereports():","generation)","genericidentityfn","genericnumb","genericnumber();","generics)","german:","get","get():","getciti","getcity();","getcity;","getclassnamesymbol","getcompiler()","getcounter():","getcounter();","getdistance(p:","getdistance의","getelevatorpitch()","getformat","getformat(target:","getformat(this,","getformat이","getgreeting()","getname(n:","getobject(done:","getpaddingstring()","getpaddingstring():","getproperti","getproperty(o:","getproperty(obj:","getproperty(taxi,","getproperty(x,","getproperty,","getproperty의","getrandompadder()","getresult()","getsmallpet():","getsmallpet();","getsomevalue(),","getter,","getters/setters를","getters와","getter도","getthing()","getthing():","getwidget","getwidget(\"al","getwidget(43);","getwidget(n:","getwidget(s:","get과","github으로","given","glob","global","global.d.t","global.d.ts은","go","good","graph","greatli","green","green,","greet","greet(\"hello\");","greet(\"hello,","greet()","greet(@requir","greet(g:","greet(getgreeting);","greet(greeting:","greet(n:","greet(new","greet(setting:","greet(y);","greet({","greet.ts를","greet.ts에서","greeter","greeter(\"hello\");","greeter(\"hello,","greeter(\"world\"));","greeter(\"world\");","greeter();","greeter(message)","greeter(person)","greeter(person:","greeter(user);","greeter.html에","greeter.html을","greeter.j","greeter.js를","greeter.prototype.greet","greeter.standardgreeting;","greeter.t","greeter.ts를","greeter1","greeter1:","greeter1은","greeter2:","greeter:","greeter;","greetermaker();","greetermaker.standardgreet","greetermaker:","greetermaker라는","greetermaker에","greeter는","greeter라고","greeter를","greeter의","greeter클래스의","greeting\"","greeting:","greetinglib","greetinglib.opt","greetinglib.options.log","greetinglik","greetinglike):","greetings\");","greetingset","greetingsettings):","greeting을","grid","grid(1.0);","grid(5.0);","grid.origin.x);","grid.origin.y);","grid.를","grid1","grid2","grid의","group","grunt","grunt.initconfig({","grunt.loadnpmtasks(\"grunt","grunt.registertask(\"default\",","gruntfile.j","guard","guards)","guidanc","guide를","gulp","gulp)","gulp,","gulp.src(\"src/*.ts\")","gulp.src(paths.libs).pipe(gulp.dest('wwwroot/scripts/lib'));","gulp.src(paths.pages)","gulp.src(paths.scripts).pipe(gulp.dest('wwwroot/scripts'))","gulp.src(paths.scripts).pipe(gulp.dest('wwwroot/scripts'));","gulp.task(\"copi","gulp.task(\"default\",","gulp.task('clean',","gulp.task('copyhtml',","gulp.task('default',","gulp.task('lib',","gulpfil","gulpfile.j","gulpfile.js)","gulpfile.js라는","gulpfile.js를","gulpfile.js은","gulpfile을","gulp로","gulp를","gulp에서","gulp을","gulp의","gutil","gutil.log);","gutil.log);을","g가","g는","g을","h","h.","h.jsx를","hand","handbook","handbook을","handlechar(char:","handler","handler();","handler,","handler:","handler의","happen","happen:","hasmask:","have","havemuscl","havemuscles;","havemuscles는","havemuscles이","height:","hello","hello(\"typescript\");","hello(compiler:","hello.tsx","hello.tsx에","hello:","helloprop","helloprops)","help","here","here.","hex:","higher)","hoare는","hoc,","home:","homeprop","homeprops):","hors","horse(\"tommi","horse는","horse와","horse의","hostname?:","hour:","howard","html","html\",","html\"],","html'","html'...","htmlcanvaselement;","htmldivelement):","htmldivelement;","htmlelement):","htmlelement;","htmlimageelement;","htmlinputelement).value;","htmlinputelement;","htmlspanelement;","html이","http://go.microsoft.com/fwlink/?linkid=518007","http://json.schemastore.org/tsconfig에서","https://aka.ms/typ","https://github.com/definitelytyped/definitelytyped에","h로","i'll","i'm","i/o","id","id(x){","id:","idea","ident","identifier!는","identifier의","identity(\"mystring\");","identity(arg:","identity;","identity를","identity와","ide를","ide에","ifitexist","if문","if문의","ignore를","iife를","imag","image와","imagin","immedi","imoprt가","impact","implement","implements와","implicit","import","import(\"./a\").pet","import(\"./a\").x","import(...)","import)","import)는","import/export의","importhelp","importing하는","imports)","imports,","imports/sid","importsnotusedasvalues.","imports나","imports는","imports를","import가","import나","import는","import된","import로","import를","import문","import문을","import에","import에서","import에서는,","import은","import의","import하는","import하지","import할","improv","in\"","in\")","in\");","inact","includ","inclusive.`);","increment","increment:","incur","indentedstr","index","index)","index,","index.d.t","index.d.ts와","index.d.ts이고","index.html","index.html에","index.html을","index.html의","index.html이라는","index.j","index.js는","index.js를","index.tsx로","index.tsx를","index.ts가","index?:","industries\",","infer","infin","infiniteloop():","info,","info:","inform","information)","inherit","init","initail","initi","inlinesourc","inlinesourcemap","input","input:","input;","input[0];","input[1];","instal","install을","instanc","instanceof","instanceof의","instancetyp","instancetype;","instead","instead\";","int32array,","integration)","intellij","intend","interact()","interfac","interface)","interface):","interface;","interfaced(arg:","interfaced에","interfaces)","interface를","intern","interoperable.","interval:","intrinsicel","introduc","invok","invokelater([1,","invokelater(args:","invokelater는","in이","is:\"","isacceptable(s:","isactive:","isdisposed:","isdone:","isfish(pet:","isfish가","ismatch","isnumber(x:","isolatedmodul","isolatedmodules,","isprim","isprime(2);","isprime(x:","isstring(x:","it'","it.","italian:","item","items.foreach((item,","items.foreach(item","item을","iter","iterable과","itself","ivogabe/gulp","i가","i를","i의","j","ja","japanese:","java","javascirpt","javascript","javascript(유사한","javascript,","javascript가","javascript는","javascript로","javascript를","javascript에","javascript에는","javascript에서","javascript에서,","javascript에서는","javascript에서의","javascript에서처럼,","javascript에선","javascript와","javascript의","javascript이기","javascript처럼","javascript처럼,","javascript파일을","java를","java와","jeremi","jeremy.#nam","jim","jim.log(jim.name);","john","join(...paths:","jqueri","jquery,","jquery.d.t","jquery;","jquery는","jquery를","jquery와","js","jsconfig.json에","jsdoc","jsdoc)","jsdocstat","jsdoc을","jsdoc의","json","jspm","jspm@beta","jspm_packag","jspm의","jsx","jsx.element","jsx.element;","jsx.element[]","jsx.elementattributesproperty가","jsx.elementattributesproperty를","jsx.elementattributesproperty에","jsx.elementchildrenattribute는","jsx.elementchildrenattribute를","jsx.elementclass는","jsx.elementclass에","jsx.element에","jsx.element의","jsx.intrinsicattribut","jsx.intrinsicclassattribut","jsx.intrinsicel","jsx.intrinsicelements에","jsx.intrinsicelements에서","jsx.intrinsicelements의","jsx:","jsxfactori","jsxfactory를","jsxfactory에","jsx는","jsx를","jsx에서","jsx와","jsx의","js를","k","k)","k):","k.","k.dosomething();","k[]):","k]:","kangaroo","katz의","keep","keeper:","keepwholeobject(wholeobject:","keepwholeobject는","kept","key","key.","key:","keyboard","keycode:","keyev","keyof","keyof를","keyof와","keys.","keys:","keys]:","keys는","kind","kind:","kitti","kitty.nam","kitty.numl","kittyset","known","ko","korean:","k는","k로","k를","k은","k의","label","label:","labeledvalu","labeledvalue)","label을","languag","larg","lastnam","lastname:","lastname;","lastname?:","lastname을","lastname의","layeggs();","layer","layout","layout)","lead","leaf","learn","left","left,","left:","leg","legs\");","length","length:","lengthwis","length는","let'","let,","letterregexp와","lettersonlyvalid","lettersonlyvalidator();","lettersonlyvalidator.t","lettersonlyvalidators.t","lettersregexp","lettersregexp.test(s);","let과","let문","let선언만","let선언은","let에","let은","let을","let의","level","level)","lf","lib","lib\";","lib.d.t","lib.d.ts,","lib.d.ts에","lib.d.ts와","librari","libraries)","library)","library.","libs:","lib가","lib에","line","line):","link","linkedlist","linkedlist;","lion","list","list){","list:","list[1]","listemittedfil","listenevent(eventtype.mouse,","listenevent(eventtype:","listfil","liter","load","loadash","loader","loader\"","loader'로","loader'에","loader'에서","loader:","loaders:","loader가","loader는","loader도","loader를","loader에","loader와","loader와sourc","loading...","local","localhost","locat","location:","lodash를","lodash와","log","log(name)","log(name:","log.t","loggabl","loggable은","loggable입니다.","loggingident","loggingidentity(3);","loggingidentity(arg:","loggingidentity({length:","loggingidentity는","loggingidentity의","logic","loglevel","loglevel;","loglevel[key];","loglevelstr","loglevelstrings,","logopt","long","longer","look","loop","luca","m","m()","m.someth","m:","m;","mackinzie\"","main()","main.j","main.t","main.ts라는","main.ts를","mainbutton(prop:","mainvalid","make","makeandmodel:","makegreeting(s:","makegreeting와,","makeobject(desc:","makeobject({","makeobject의","makesound():","manag","manufactur","manufacturer:","manufacturer과","many/too","map","map\",","map(f:","map,","map.t","mapping)","mappings)","maproot","maps.","master","match","match\"","match\"}`);","math","math.floor(math.random()","math.floor(pickedcard","math.floor(x","math.pi","math.random()","math.sin(this.value);","math.sqrt(dx","math.sqrt(xdist","mathlib.isprime(2);","mathlib;","matter","max","maxbas","maxbase)","maxnodemodulejsdepth","mean","meanings)","meant","meet","member","members)","memori","merges)","merging으로","messag","message\");","message:","message;","metadata","metadata\":","metadata\";","metadata)를","metadata라이브러리를","method","method()","method.apply(this,","method2()","methodonly는","methodonly의","methods)가","methods:","methods?:","microsoft.aspnetcore.staticfil","microsoft.typescript.compiler:","microsoft.typescript.default.prop","microsoft.typescript.default.props,","microsoft.typescript.msbuild:","microsoft.typescript.msbuild를","microsoft.typescript.target","middleiniti","middleinitial:","midnight까지","mind","minute);","minute:","miss","mistake)\"라고","mitig","mixcolor(colorname:","mixin","mixin을","mixin의","mkdir","mod_1","mod_1)","mod_1.someth","mod_1;","mod_1_1;","modal:","mode","mode:","model","model.ts라는","model:","modelyear","model과","model은","model이","mode에서는","modifi","modifier)","modifiers)","modul","modular","module\";","module)","module.d.t","module.d.ts,","module.export","module.exports)","module.exports.feedpet","module.exports.readfil","module.exports에","module.exports와","module.js\"","module.js\";","module:","modulea","modulea)","modulea.callstuff()","modulea.t","modulea:mytyp","modulea는","modulea를","moduleb.j","moduleb를","moduleb의","moduleresolut","modules)","modules,","modules.","modules를","modules은","module과","module에","module을","module의","module이","moment","moment().utcoffset(x);","moment.j","moment.js,","moment.js에서,","moment;","monday","month.\";","month.`;","more","more.","mouse,","mouseev","mouseevent)","mouseevent).x","mouseevent).y));","mouseevent가","move","move():","move()를","move(distanceinmet","move(distanceinmeters:","move(pet:","moveby(dx:","move를","mozilla","ms","msbuild","msbuild에","msbuild에서","msbuild에서의","much","much.","multipl","multipli","multiply(operand:","multiply는","my.application.customer.addform과","my.application.order.addform","myadd","myadd:","myadd는","myapp","myarray","myarray:","myarray[0];","myarray[2]","myarray[2]의","myarrow","myclass.t","mycompon","mycomponent();","mycomponent가","mycoolfunction()","mycoolfunction(f:","mycoolfunction(function(x)","mycoolfunction가","mycoolfunction에","mycoolfunction이","mydeck","mydeck[pickcard(mydeck)];","myelem:","myelement","myfactoryfunct","myfactoryfunction()","myfactoryfunction();","myfunc.t","mygenericnumb","mygenericnumber.add","mygenericnumber.zerovalu","mygreet","mygreeter());","mygreeter.greet","mygreeter.showgreeting();","myidentity:","mylargemodul","mylargemodule.dog();","mylargemodule.t","mylib","mylib.makegreeting(\"hello,","mylib.numberofgreetings;","mylib를","mylib에는","mymodel","mymodel();","mymodules.d.t","myobj","myothermodule.t","mypet.name;","mypet;","mysearch","mysearch:","mysquar","mystr:","mytestpage.html","mythings.t","myurl","myvalid","n","n();","n)","n,","n.name);","n:","n;","name","name!.charat(0)","name)","name));","name).","name,","name.charat(0)","name:","name:string이라는","name;","name?:","named)","named)만","named;","namedmodul","nameofa","nameorresolv","nameorresolver):","nameresolv","nameresolver;","names)","namespac","namespace)","namespaces)","namespace를","namespacing)","nametag:","name은","name을","name의","name이라는","nan","nas;","nativ","native라는","navig","nds;","need","need.","network)에서","network를","network의","never","never):","never)을","never;","never는","never로","never를","never에","never타입은","new","new:","newlin","newmember:","newname.length","newname1","newname1,","newname2","newname;","newname의","newproperti","newsquar","newsquare.area","newsquare.color","newsquare;","new를","new의","next","next:","nightli","nightlies는","no!","no!\";","nocheck","node","node.d.t","node.d.ts를","node.d.ts파일을","node.j","node.js)","node.js/io.j","node.js가","node.js나","node.js는","node.js를","node.js에서","node.js에서는","node.js에서만","node.js의","node/commonj","node/commonjs를","node].","node_modul","node_modules,","node_modules/@typ","node_modules로","node_modules안에서","node_modules에","node_modules에서","node_modules을","node_modules의","node가","node는","node로","node의","noemit","noemithelp","noemitonerror","noerrortrunc","nofallthroughcasesinswitch","nofallthroughcasesinswitch는","noimplicitani","noimplicitany,","noimplicitany:","noimplicitany는","noimplicitany를","noimplicitreturn","noimplicitreturns는","noimplicitthi","noimplicitthis,","noimplicitusestrict","nolib","nolib을","non","none,","nonfunctionproperti","nonfunctionproperties;","nonfunctionpropertynam","nonfunctionpropertynames;","nonnul","nonnullable)","nonnullable;","noresolv","noresolve)","noresolve가","noresolve를","normal","normal;","normalize(p:","normally,","nostrictgenericcheck","notavalidcompon","notavalidfactoryfunction()","note","note:","notempti","notempty;","noth","notokay","notsur","notsure.ifitexists();","notsure.tofixed();","notsure:","nounusedloc","nounusedparamet","now","npm","npm)","npm3에서","npm과","npm에","npm으로","npm을","npm의","npx","ns","ns.c","ns.const","ns.func","ns;","ns를","nuget","nuget과","nuget를","nuget에","null","null'에","null(","null)","null):","null);","null,","null;","null];","nullability는","nullabl","nullable;","nullableperson","nullable이","nullish","null과","null과는","null로","null에서","null은","null을","null의","null이","null이나","null입니다.","num","num:","number","number'","number(이)거나","number)","number),","number).","number):","number);","number)[]","number,","number;","number;})","number=","number[]","number[]):","number[];","number[][])","number]'","number])","number]:","number];","numberdictionari","numberofgreet","numberofgreetings:","numberoflegs:","numberorstr","numberorstringdictionari","numberregexp","numberregexp.test(s);","numberregexp는","numbers){","numbertostring(n:","number|string)","number|string):","number|undefined에","number}","number}}","number}타입엔","number가","number는","number라는","number로","number를","number에","number와","number의","number일","numer를","numfeet:","numlegs:","numlives:","numlivesforcat","numlivesforcat,","nums:","numspaces:","n은","n을","o","o.a,","o.a;","o.b;","o.b로","o.map(x","o:","o;","o[n]);","o[propertyname]:","o[propertyname];","o[propertyname]는","obj","obj.b","obj.i","obj.moveby(5,","obj.property가","obj.x","obj.x;","obj2:","obj:","obj[\"property\"]로도","obj[key];","object","object\"};","object)","object,","object.cr","object.defineproperty(derivedctor.prototype,","object.freez","object.getownpropertydescriptor(basector.prototype,","object.getownpropertynames(basector.prototype).foreach(nam","object.seal(constructor);","object.seal(constructor.prototype);","object:","objectdescriptor","objectdescriptor):","objects,","object}}","object가","object나","object는","object로","object를","object보다","object와","object타입을","obj에","observ","observable.prototype.map","observable.prototype.map에","observable.t","observable;","octal:","octopu","octopus(\"man","octopus의","octopus클래스입니다.","of.","off","ok","old","omit","omit;","omitthisparamet","on","on.","onc","onclickbad(this:","onclickbad가","onclickgood","onclickgood(this:","onclickgood이","onclick이","onetwothree.t","onload:","only\"]","only)","oops!","oo의","opacity:","open","oper","operand;","operator)","operator:","operator;","option","option1:","option2:","optionalprop?:","options.","options.color","options.prop1","options.prop2","options.prop3","options.prop5;","options.volum","options;","options에","options의","orchestr","order","organ","organization에","origin","originalprop","origin에","other.#sidelength;","out","out\"","out\"'","out\")","out\";","out)","out:","outdir","outdir로","outer()","outer.inn","outfil","outfile,","outfile과","outfile을","output","output)을","output.","output:","overal","overhead","overloads)","ownersaddress:","p","p)","p,","p.i","p.x","p0()","p0(value:","p1","p1()","p1(value:","p1.join();","p1.x","p1:","p2","p2,","p3,","p4){","p:","p;","packag","package)","package.json","package.json가","package.json라는","package.json안에","package.json에","package.json에도","package.json을","package.json의","package.json이","packagecache:","packages:","packages를","pad","padder","padding:","padding에","padding이","padleft","padleft(\"hello","padleft(value:","padleft에서","padleft의","page","page)","pageinfo","pages:","pair","palomino","palomino\");","paragraph","param","param1","paramet","parameter)","parameterindex","parameterindex:","parameternam","parametername는","parameters(arg:","parameters)","parameters;","parent","parse(urlstr:","parseint(e)","parseint(s).tostring()","parseintbasedzipcodevalid","parseintbasedzipcodevalidator.t","parsequerystring?,","part","part[]","part[];","parti","partial","partial)","partial.name은","partial;","partialperson","partialwithnewmemb","partial가","partial처럼","party)","pass","passthrough.b","passthrough.c.length;","path","path.join(__dirname,","pathname?:","paths[2]","pattern","pattern\"이라고","peer","penstrok","penwidth:","people.name;","people.next.name;","people.next.next.name;","people.next.next.next.name;","people:","person","person(\"jeremi","person(\"john\");","person('jim'),","person();","person)","person.firstnam","person.lastname;","person.name이","person;","person['name']","person['name']은","person[p]","person]:","person]?:","personparti","personreadonli","person에서","person을","pet","pet)","pet.fly();","pet.fly()를","pet.layeggs();","pet.swim();","pets){","pets[\"species\"]","pet의","pet이","pick","pick;","pick>;","pickcard","pickcard(15);","pickcard(x):","pickcard(x:","pickcard가","pickcard를","pickedcard","pickedcard.card","pickedcard.suit);","pickedcard1","pickedcard1.card","pickedcard1.suit);","pickedcard2","pickedcard2.card","pickedcard2.suit);","pickedcard;","pickedsuit","pick과","pick은","piec","pieces.","pl","place","playground에","pluck(o,","pluck(o:","pluck(taxi,","pluck에","pluck처럼","plugin","plugin)","plugin.d.t","plugins)","point","point)","point):","point,","point.prototype.distancefromorigin","point3d","point3d:","point:","point;","point를","point입니다.","polish:","polyfills.js',","polygon","polygons.square();","polymorphism이라고","portuguese(brazil):","possibl","possible)","postfix(\"great\");","postfix(epithet:","powershel","practic","pragma","preact","preact.h","preact.h(\"div\",","predic","predicates)","prefer","preferreduilang","prefix","preloaders:","prepend","presenc","present","preserv","preserve,","preserve:","preserveconstenum","preservesymlink","preset","presets:","preset을","pretti","pretty[1]","prettysure.tofixed();","prettysure:","pretty를","previously,","price:","primit","print","printimportant(key:","printlabel","printlabel(labeledobj:","printlabel(myobj);","printlabel에","printmeeting():","printname():","printstuff()","prioritypollinginterval:","privacy)","privacy)\"는","privacy)는","privat","private)","private,","private과","private에서는","private으로","private을","private지정자와","private프로퍼티","probabl","problem","problems,","process","process,","processdigit(digit:","produc","program","program.","programmercalcul","programmercalculator.digits.indexof(digit);","programmercalculator.digits.length;","programmercalculator.t","programmercalculator.ts을","proj","proj$","proj/","project","project'","project)","project,","project.","project.json에서","projectroot","projectroot/folder1/file2.t","projectroot/folder2/file3.t","projectroot/generated/folder2/file3.t","projects,","projects.","projects;","proj라고","proj의","proj이라는","promis","promise((resolve,","promise;","promisedstring;","promise과","prop","prop'은","prop1","prop1:","prop2","prop2:","prop3","prop3?:","prop:","propa:","propb:","properti","properties)","properties,","property\";","property,","propertydescriptor)","propertykey)","propertykey);","propertykey:","propertyname);","propertyname:","propertynames)","propertynames.map(n","propertynames:","props:","props;","propstyp","props나","props와","props의","protect","protected)","protected,","protected로","protected와","protocol?:","prototyp","provid","proxi","proxifi","proxify(o:","proxify(props);","proxify):","proxy;","proxyprop","ps(){}","pst","pt","public","public,","public과","public으로","public을","public입니다.","publish","publishing에서","pull","purrs:","put","python","python\");","q","question;","questions)","quick","quickli","quirks)","r","r.js)와","r;","r>","radius:","rang","range는","rc1","re","react","react!","react!\"","react.compon","react.component는","react.createel","react.createelement(\"div\")","react.createelement(\"div\")과","react.createelement(\"mycomponent\")가","react.createelement(기본값)로","react.createelement)","react.createelement를","react.jsx를","reactdom","reactdom.render(","reactnamespac","react로","react를","react와","react의","read","readfile`과","readonli","readonly,","readonly;","readonlyarray","readonlyarray를","readonlyperson","readonlystringarray","readonly나","readonly도","readonly로","readonly를","readonly와","readonly키워드를","ready,","reason,","recommend","record","record가","record는","record와","rectangl","red","red,","reduc","ref","refer","referenc","reference,","reference:","reference?","references)","references.","references;","reflect","reflect.definemetadata(requiredmetadatakey,","reflect.getmetadata(\"design:type\",","reflect.getmetadata(formatmetadatakey,","reflect.getownmetadata(requiredmetadatakey,","reflect.metadata","reflect.metadata(formatmetadatakey,","regexpbasedzipcodevalidator}","regist","registerclass(c)","reject()","reject)","rel","remot","remove:","removecom","renam","renaming)","render()","render:","repo","reports...\");","request,","request를","request에서","request와","request을","requir","require(\"...\")","require(\"...\");","require(\"./a\").x;","require(\"./mod\");","require(\"./moduleb\");라는","require(\"./zipcodevalidator\");","require(\"bar\");","require(\"browserify\");","require(\"duo","require(\"duo\");","require(\"express\");","require(\"foo\");","require(\"fs\")","require(\"fs\");","require(\"gulp","require(\"gulp\");","require(\"mag","require(\"mod\");","require(\"module\")를","require(\"moduleb\");","require(\"moment\");","require(\"mylib\");","require(\"mylib/bar\");","require(\"mylib/bar/baz\");","require(\"mylib/foo\");","require(\"path\")","require(\"preact\");","require(\"tsify\");","require(\"url\");","require(\"watchify\");","require('browserify');","require('del');","require('gulp","require('gulp');","require('somelib');","require('tsify');","require('vinyl","require()","require())","require([\"./zipcodevalidator\"],","require(modulename:","require(modulenames:","require(path:","require.j","require.js)","require.js에서","require.js의","required(target:","requiredmetadatakey","requiredparameters)","requiredparameters:","requiredprop:","requiredprop은","requiredprop이","requirej","requirejs/amd를","requirejs는","requirejs를","requirejs와","require를","require에","reset():","resolut","resolution)","resolv","resolve:","respect","respond(\"princess","respond(recipient:","respons","response):","response.text();","response.yes)","rest","restofname.join(\"","restor","result","result);","result.","result1","result2","result3","result4","result:","result;","result[k]","results)","results.","results.code);","return","return;","returntyp","returntype()","returntype;","revers","reverse(s:","reverse;","rhino","rhino(),","rhino();","rhino,","rhino;","rhino가","rhino는","right","right,","right:","right;","ro","ro.length","ro.push(5);","ro:","ro;","ro[0]","rolldice():","room',","root","root.returnexport","rootdir","rootdirs)","rootdirs[2]","rootdirs를","rootdirs의","roots를","ru","rules)","rules:","run","runner","runtim","runtime)","russian:","s","s.height","s.length","s.radiu","s.size","s.size;","s.width;","s1:","s2:","s:","s;","safety)","sam","sam.move();","same","sammi","sampl","sample)","sample.j","samuel","save","savingcomments:","sawasterisk:","sayhello","sayhello()","sayhello();","sayhello(name);","sayhello(name:","sayhello(somebody)","sayhello를","sb;","sbn2;","sbn;","scale","scale:","scenarios)","scene","scientificcalcul","scientificcalculator(2)","scientificcalculator는","scientificcalculator을","scope","scoping)","scripthost","scripts/app.ts를","scripts:","scripts라고","scripts를","scripts에","seal","sealed(constructor:","sealed(target)","search","searchfunc","searchfunc;","search는","second","second)","second):","second)[prop]","second,","second:","second;","second[prop];","second]","second]:","seconds)","second라는","second의","see","select","select()","select():","select:","selectablecontrol","selectablecontrol를","selectablecontrol은","selectablecontrol의","selection;","selector","selector:","sentence:","sentence선언과","sep:","separ","serializ","seriou","serious():","seriousaliz","seriousalize(key,","server)","set","set([\"cat\",","set(value:","set,","set.call(target,","setinterval(()","setters:[","setters가","setter를","setter에서만","settim","settime(d:","settimeout","settimeout(()","settimeout예제를","settimeout은","settimout에","setting,","set과","set을","set이","sfc","shadow","shadowing)","shadowing은","shadowing의","shadowing이라고","shape","shape)","shape):","shape,","shapeconsumer.t","shapekind","shapekind.circle;","shapekind.square,","shapekind.square;","shapes.polygons.square()'와","shapes.polygons;","shapes.shapes.triangle();","shapes.shapes?","shapes.t","shapes.triangle();","shapes는","shape에","sheep):","sheep;","shift","shims은","short)","show","showgreeting():","showhello","showhello(\"greeting\",","showhello(divname:","showhello에","side","side:","sidelength:","sidelength;","sideprop","sideprops):","signatuer)을","signature)로","signature)를","signatures)","simpl","simplemodule.j","simplemodule.t","simpli","simplifi","sin","sin()","singl","situat","size","size:","size;","skip","skipdefaultlibcheck","skipdefaultlibcheck를","skiplibcheck","skiplibcheck를","slash)","slashesdenotehost?):","slithering...","small","smaller","smart","smartobj","smartobj.interact(),","smartobject","smartobject();","smith\"","smith\"));","smith\";","smrq/tsifi","sn","sn:","sn;","snake","snake(\"sammi","snake()];","snake)[]과","snake.","snake와","solut","solv","somearray","somearray)","somebodi","somebody);","somefunc","somefunc()","somefunc();","somelib","somelib.thing;","someobj","someth","sometyp","sometype();","sometype,","sometype과","somevalue:","somevar:","somevar는","somewher","sortableset","soundness)","sourc","source(vinil","source.search(substring);","sourcemap","sourcemaps');","sourcemaps도","sourcemaps에","sourcemaps이","sourcemap에","sourcemap을","sourceroot","space)에","spacerepeatingpadd","span)","spanish:","special","special(options)","specialgreet","specialtyp","specialtype1","specialtype1의","specialtypeobject1;","specialtypeobject;","specialtype과","specialtype의","specif","specifi","specified,","speed","spread","spuriou","sq","squar","square(100);","square,","square.color","square.penwidth","square.sidelength","square;","squareconfig","squareconfig):","squareconfig);","squareconfig가","squareopt","squareoptions가","squareoptions와","square을","src","src.search(sub);","src/","src/compon","src/components에","src/greet.t","src/greet.ts를","src/main.ts의","src/tsc/tsconfig.json","src/tsconfig.json","src/tsconfig.json,","src/tsconfig_base.json,","src/view","src:","src에","src와","src의","stage","standardgreet","star;","start","startup","startup.cs에서","state","state:","statelesscomponent은","statements)","state는","state라는","static","staticzipcodevalidator.t","static을","statu","status.ready;","step...\"","steps)","still","strategies)","stream","stream');","stream에","stream을","strict","strict\"","strict\"을","stricter","strictfunctiontyp","strictfunctiontypes가","strictfunctiontypes을","strictfunctiontypes이","strictnullcheck","strictnullchecks:","strictnullchecks`","strictnullchecks가","strictnullchecks도","strictnullchecks를","strictnullchecks을","strictnullchecks이","strict를","string","string\";","string'","string)","string).length;","string):","string);","string)으로","string,","string.prototype.match","string.prototype.replac","string.prototype.search","string.prototype.split","string.prototype에","string;","string;)","string;)에는","string>;","string[]","string[])","string[],","string[];","string]:","stringarray","stringarray;","stringarray가","stringnumer","stringnumeric.add","stringnumeric.zerovalu","stringpadd","strings)","strings.","strings.foreach(","stringsstringstrings(p1,","stringtonumber;","stringvalid","stringvalidator.t","stringvalidator;","stringvalidator{","string}","string}'","string});","string},","string라는","string으로","string을","string이","string이나","string혹은","stripintern","stripinternal[1]","strlength:","strong","structnullchecks를","structur","structures)","student","student(\"jane\",","studio","studio과","studio는","studio에","studio에게","studio에서","sub)","sub1:","sub:","subdirectori","subfold","sublim","subparts:","subproject","subsequ","substring:","subtyping)\"이라고도","successfulli","sudo를","suffix","suit","suit\";","suit:","suits:","suits[pickedsuit],","sum","sum(/*","summatrix","summatrix(matrix:","super(\"account","super(\"rhino\");","super(\"veri","super();","super()를","super(name);","super(value);","super.move(distanceinmeters);","support","supported)","suppressexcesspropertyerror","suppressimplicitanyindexerror","swim();","switch","switch.","switch가","switch블록","sym","sym1","sym2","sym3","sym3;","symbol","symbol(\"format\");","symbol(\"key\");","symbol(\"required\");","symbol();","symbol,","symbol.hasinst","symbol.isconcatspread","symbol.iter","symbol.iterator프로퍼티에","symbol.match","symbol.replac","symbol.search","symbol.speci","symbol.split","symbol.toprimit","symbol.tostringtag","symbol.unscop","symbols)","symbol생성자를","symbol은","symlinked된","symlinks를","synchronouswatchdirectory:","syntax","syntax)","syntaxerror","syntaxerror!","system","system.collections에서","system.config({","system.import(\"./zipcodevalidator\").then((zipcodevalidator:","system.import('scripts/main').then(null,","system.js)","system.js에서","system.register([\"./mod\"],","system:","systemj","systemjs,","systemjs나","systemjs를","system를","system인","s가","s는","t","t();","t)","t):","t)>;","t)을","t,","t,u,v","t0","t00","t01","t02","t03","t04","t05","t1","t10","t11","t12","t13","t14","t15","t16","t17","t18","t2","t20","t21","t22","t23","t24","t3","t30","t31","t32","t33","t34","t35","t4","t40","t41","t42","t43","t5","t6","t7","t8","t;","t[]","t[]):","t[k]","t[k].get();","t[k][]","t[k]가","t[k]를","t[k]입니다.","t[number]로","t[p]","t[p];","t[p]에","t[p]의","t[string]은","t]:","t];","t]?:","target","target,","target과","target을","task","taxi:","team","techniques)","templat","template)","template1.t","template:","templor","tempor","test","test(c,","test(c:","test).","test.t","test:","testcalculator.t","testing:","testprogrammercalculator.t","tests.t","tests에","text","textbox","text를","thecitythatalwayssleeps()","them\");","thename;","thename을","thename의","thename이라는","theory:","there!\"","there!\";","there\"","there\";","there'","thing","things)","things:","this)","this,","this.#foo","this.#foo;","this.#nam","this.#sidelength","this._fullnam","this._fullname;","this._i","this._p0","this._p0;","this._p1","this._p1;","this._x","this._x;","this._y;","this.activate();","this.bas","this.clientheight","this.constructoronli","this.constructorunknown","this.count;","this.curr","this.current);","this.current;","this.currenttim","this.depart","this.evaluate();","this.evaluateoperator(this.operator,","this.foo;","this.fullnam","this.getdistance({","this.greet","this.greeting);","this.greeting;","this.hello","this.i","this.info","this.info까지","this.info를","this.initialize(data);","this.isact","this.isdispos","this.isdisposed),","this.l","this.memori","this.memory,","this.memory;","this.methodonli","this.model.compiler;","this.nam","this.name);","this.oper","this.processdigit(char,","this.processoperator(char);","this.prop","this.props.b;","this.props의","this.scale;","this.siz","this.stuff","this.suits[pickedsuit]","this.suits[pickedsuit],","this.suits[pickedsuit]의","this.tostring(16);","this.valu","this.value;","this.x","this.x;","this.y;","this.yi","this.를","this:","this;","thisparametertyp","thisparametertype)","thistyp","thistype;","thistype를","this가","this는","this로","this를","this에","this와","this의","this타입에","this타입을","those","though","three:","three?:","threestringprop","throw","tick()","tick():","tick();","time","time\");","time)","timeout?:","times,","timestamp","timestamp:","title:","title?:","tock\");","todo","todo,","todo.titl","todo1","todo2","todo:","todopreview","tofixed는","together)","tohex(this:","tohex.apply(n);","tohex.bind(5);","tolowercase()와","tom.move(34);","tom.move(34)는","tom:","tommi","tom은","toni","toobservable():","tool","tools)","toolsvers","top","topics)","toprimit","total","tr","traceresolut","traceresolution'을","traceresolution으로","trade","tradit","transform","transit","transpar","transpilemodul","trash',","tree","tree;","tri","triangl","triangle;","triangle과","triangle을","true","true)","true);","true,","true;","true];","true}))","true로","true를","ts","ts\");","ts.createproject(\"tsconfig.json\");","ts2307:","ts2345:","ts:","tsc","tsc,","tsc.","tsconfig","tsconfig.fullbuild.json이나","tsconfig.json","tsconfig.json)","tsconfig.json.","tsconfig.json:","tsconfig.json과","tsconfig.json는","tsconfig.json를","tsconfig.json에","tsconfig.json에서","tsconfig.json에서만","tsconfig.json와","tsconfig.json은","tsconfig.json을","tsconfig.json의","tsconfig.json의\"lib\"컴파일러","tsconfig.json이","tsconfig.json이라는","tsconfig.json파일을","tsconfig.nostrictnull.json:","tsc를","tsc와","tsifi","tsify는","tslib로부터","tsproject","tsproject.src()","tsresult","tsresult.js.pipe(gulp.dest(\"built/local\"));","tsscript","ts는","ts로","ts를","tuple:","tuple;","turkish:","turn","tw","twice","two","two:","two?:","type","type)","type)\"이","type))","type,","type.\");","typecheck","typedpropertydescriptor)","typeerror","typeerror(\"invalid","typeerror:","typeifi","typenam","typename;","typename은","typeof","typeof를","typeroot","typeroots를","types)","typescript","typescript!\",","typescript!\"를","typescript\"","typescript\");","typescript\"가","typescript)","typescript,","typescript.d.t","typescript@next","typescript@next가","typescriptadditionalflag","typescriptallowsyntheticdefaultimport","typescriptallowunreachablecod","typescriptallowunusedlabel","typescriptalwaysstrict","typescriptbaseurl","typescriptcharset","typescriptcompileblock","typescriptdeclarationdir","typescriptemitbom","typescriptemitdecoratormetadata","typescriptexperimentalasyncfunct","typescriptexperimentaldecor","typescriptforceconsistentcasinginfilenam","typescriptgeneratesdeclar","typescriptimporthelp","typescriptinlinesourc","typescriptinlinesourcemap","typescriptisolatedmodul","typescriptjsxemit","typescriptjsxfactori","typescriptlib","typescriptmaproot","typescriptmodulekind","typescriptmoduleresolut","typescriptnewlin","typescriptnoemithelp","typescriptnoemitonerror","typescriptnofallthroughcasesinswitch","typescriptnoimplicitani","typescriptnoimplicitreturn","typescriptnoimplicitthi","typescriptnoimplicitusestrict","typescriptnolib","typescriptnoresolv","typescriptnostrictgenericcheck","typescriptnounusedloc","typescriptnounusedparamet","typescriptoutdir","typescriptoutfil","typescriptpreserveconstenum","typescriptpreservesymlink","typescriptreactnamespac","typescriptremovecom","typescriptrootdir","typescriptsamples/jspm","typescriptskipdefaultlibcheck","typescriptskiplibcheck","typescriptsourcemap","typescriptsourceroot","typescriptstrict","typescriptstrictfunctiontyp","typescriptstrictnullcheck","typescriptstripintern","typescriptsuppressexcesspropertyerror","typescriptsuppressimplicitanyindexerror","typescripttarget","typescripttoolsversion이","typescript’","typescript가","typescript나","typescript는","typescript도","typescript로","typescript를","typescript만의","typescript보다","typescript에","typescript에는","typescript에서","typescript에서,","typescript에서는","typescript에서는,","typescript에서도","typescript와","typescript의","typescript처럼","typestrong/grunt","types를","types을","type과","type선언이","type은","type을","typing\"","typing)","typing)\"","typing)이","t가","t나","t는","t라는","t를","t에","t에는","t에서","t와","t의","t이고","t인지","u","u)","u):","u)[]","u,","u:","uglifi","uglify');","uglify는","uglify를","uglify와","ui","uielement","uielement();","uielement.addclicklistener(h.onclickbad);","uielement.addclicklistener(h.onclickgood);","uievent","uievent가","uievent는","uint32array","umd","umd)","umd,","umd가","umd로","umd를","umd입니다.","undefin","undefined'에","undefined)","undefined);","undefined)?]","undefined,","undefined;","undefined>;","undefined}","undefined가","undefined나","undefined는","undefined라는","undefined로","undefined를","undefined와","undefined을","undefined이","unexpect","union","unions)","units,","unknown","unknown[]","unknownprop은","unknown을","unless","unnecessari","unpack","unpacked;","unpacked>;","unpacked[]>;","unpacked[]>>;","unproxify(proxyprops);","unproxify(t:","until","unus","unusable:","up","up,","updat","updatepart(newname:","updatetodo(todo1,","updatetodo(todo:","up이","url","url)","url.parse(\"http://www.typescriptlang.org\");","url;","us","us.","usag","usage)","use:","use?)","usedefaultfiles와","usefsev","usefseventsonparentdirectory:","usejsdoc.org에서","user","user\";","users',","usestaticfil","usual","utcoffset():","utcoffset(b:","utf","util","util\");","u가","u를","u에","v","v;","valid","validate(target:","validation.letteronlyvalidator).","validation.lettersonlyvalidator();","validation.stringvalidator;","validation.t","validation.zipcodevalidator();","validation{","validation이라는","validator();","validator.isacceptable(s)","validator.zipcodevalidator();","validators)","validators:","validators[\"lett","validators[\"zip","validators[name].isacceptable(s)","validators[name].isacceptable(s);","validator를","validator의","valu","value)","value);","value:","value;","values)","var","var9;","variabl","variable,","variables)","variant)","var대신","var로","var를","var문","var보다","var선언은","var에","var와","verbos","verbose)","verbose:","verbose?:","veri","version","via","view","view1.t","view2.t","vinyl","vinyl으로","violated,","visibl","visual","visualstudio2015","visualstudio에","void","void)","void),","void):","void);","void)>;","void,","void;","void>;","void는","void로","void를","void에","void일","void처럼","volume:","volume과","vs","vs.","vs2015","vs2015의","vs2017","vs2017의","vscode","vsdevmode.ps1","vs를","vs와","w","w,x","wait","walk(p)","want","warn","warn,","warnuser():","wasn't","wat?","watch","watch:","watchdirectory:","watchedbrowserifi","watchedbrowserify.on(\"log\",","watchedbrowserify.on(\"update\",","watchfile:","watchifi","watchify(browserify({","watchify,","watchify가","watchify로","watchify를","watchify에","watchopt","watchoptions는","watchoptions란","way","ways.","we'r","we'v","weakmap은","weakmap을","web","webpack","webpack.config.j","webpack에","webpack으로","webpack은","webpack을","webpack의","webpack이","webwork","well","well.\");","weren't","what'","wherein","whether","wholeobject;","wholeobject라는","widget","widget;","widget[]","widget[];","widget을","width","width:","width?:","width가","win;","window","window.creategreet","window.onmousedown","window.onscrol","window.onscroll에","window.somenam","window가","window로","window에","with.","within","without","woof!');","word와","work","workflow","workflows,","world","world!","world!\";","world\"","world\"\"","world\");","world\",","world\";","world\"를","world\"인","worri","wouldn't","write","writetostuff()","written","wrong;","www.myget.org에서","wwwroot","wwwroot에","x","x(\"hello\");","x()","x();","x()는","x(42);","x(y);","x)","x);","x,","x.diff(\"something\",","x.length);","x.push(\"string\");","x.push(1);","x.tofixed());","x.y.z를","x.z","x:","x;","x[3]","xdist","xml","x가","x는","x라고","x라는","x로","x를","x에","x와","x의","y","y()","y)","y));","y)로","y,","y.push(\"string\");","y.push(1);","y:","y;","y?)","y?:","ydist","ydist)","ye","year","year:","year를","yehuda","yehuda의","yike","you'd","you'll","you'r","y가","y는","y로","y를","y에","y에서","y의","z","z:","z;","z]+$/;","za","zcv","zcv();","zebra","zerovalue:","zh","zip","zip();","zip)","zipcodevalid","zipcodevalidator();","zipcodevalidator.numberregexp.test(s);","zipcodevalidator.t","zipcodevalidator.zipcodevalidator();","zipcodevalidator:","zipcodevalidator;","zipcodevalidators.t","zone에","zone입니다.","zoo","zoo:","zookeep","zookeeper;","z를","{","{!number}","{\"thi","{(data:","{(s:","{(string","{*}","{...number}","{...string}","{?number}","{?}","{[\"foo\",","{a:","{a:number}에","{anormalfunction}","{apiresponsetype}","{array.}","{array}","{boolean}","{bootstrap}","{color:","{component}","{function(number):","{function(string,","{function}","{height:","{htmlelement}","{i","{k}","{myapp}","{mymodel}","{name:","{new():","{number","{number=}","{number[]}","{number}","{object.}","{object}","{pet}","{predicate}","{promiselike}","{props.children}","{props.compiler}","{props.framework}!;","{red","{red,","{seriousalizable}","{set}","{size:","{specialtype1}","{specialtype}","{string","{string=}","{string}","{suit:","{test.a.charat(0)};","{this.props.children}","{this.props.compiler}","{this.props.foo}","{this.props.framework}!;","{typeof","{t}","{value:","{window}","{x:","{y}","{zipcodevalid","{{","{{a:","{{getcompiler()}}`","{{new(...args:","{}","{})","{}));","{}):","{},","{};","{}가","{}로","{}를","{}와","{}을","{}이지만,","{를","|","|,","||","}","}\"","}'","}'.`);","}(this,","})","})();","})(enum","})(function","}));","}).plugin(tsify));","}):","});","})}","})로","},","}.","}:","};","}>;","}[]):","}[keyof","}]","}],","}];","}`);","}}","}과","}를","}와","}을","}인","}입니다.","~","~/src/proj/gulpfile.j","~~~","~~~~","~~~~~","~~~~~~~","~~~~~~~~~","~~~~~~~~~~~","~~~~~~~~~~~~~~~","~~~~~~~~~~~~~~~~~~~~~~","—","↥","│","└─","└──","└───lib","└───src","└───typescript","├─","├──","├───node_modul","►","가","가까운","가깝게","가끔","가끔,","가능","가능/생성","가능성","가능성을","가능성이","가능을","가능케","가능하거나","가능하게","가능하고,","가능하다고","가능하다는","가능하도록","가능하며","가능하면","가능하므로","가능하지만","가능하지만,","가능한","가능함을","가능합니다)","가능합니다.","가능합니다:","가능해야","가능해야합니다.","가독성","가독성을","가드","가드,","가드는","가드라는","가드로","가드를","가드에","가드와","가드의","가려져","가려지기","가로채는","가르치며,","가르킵니다.","가리기","가리키는","가리키도록","가리킵니다.","가상","가상의","가시성","가이드는","가이드는,","가이드를","가이드에서는,","가장","가정","가정을","가정하고","가정하는","가정할","가정합니다.","가정합니다.즉","가정해봅시다.","가져","가져야","가져야만","가져오고","가져오기","가져오기(일반적으로","가져오기를","가져오기만","가져오기에서","가져오는","가져오는데","가져오도록","가져오려면","가져오면,","가져오지","가져오지만,","가져온","가져온다는","가져올","가져옵니다.","가져옵니다:","가져와","가져와야","가져왔습니다.","가졌는지만을","가지","가지가","가지게","가지고","가지기","가지는","가지를","가지며","가지면","가지므로","가지의","가지지","가진","가진다는","가질","가질만한","가질수","가짐을","가집니다","가집니다.","가집니다:","가짜","각","각각","각각의","각자","각주","각주가","각주를","간","간격으로","간결하고","간결합니다.","간단하게","간단하고","간단하지만,","간단한","간단합니다.","간단합니다:","간단해","간단히","간략하게","간에","간의","간접","간주되기에","간주됩니다).","간주됩니다.","간주됩니다.구체적으로","간주하는","간주하지","간주할","간주합니다.","간주합니다:","갈수록","감사하겠습니다.","감시","감시는","감시되는","감시를","감시와","감시하는데","감싸","감싸겠습니다.","감싸고","감싸는데","감싸주었습니다.","감싸줄","감싸지며,","감쌀","감쌉니다.","감지하고","감지하기","감지하는","감지할","감지합니다.","감춰","값","값)","값,","값과","값도","값들로","값들은","값들을","값들의","값들이","값만","값에","값에서","값으로","값은","값을","값의","값이","값이기","값이든","값이라고","값인","값인지","값일","값입니다.","강력하고","강력한","강요되지","강요합니다.","강제로","강제하기","강제하는","강제합니다.","강하게","강한","강화된","갖게","갖고","갖는","갖는)","갖도록","갖습니다.","갖습니다.\"include\"와","갖습니다.지원되는","갖습니다;","갖지","갖춰야","같게","같기","같다고","같도록","같습니다.","같습니다:","같아보이는","같아야","같으므로,","같은","같은),","같을","같음","같음)","같이","같지만","개","개념,","개념과","개념들","개념들을","개념으로의","개념은","개념을","개념이","개념이지만","개든","개발","개발을","개발자","개발자가","개발자는","개발자들","개발자들은","개발자들이","개발자인","개발할","개방되어","개별","개별적으로","개별적인","개수가","개수의","개요","개요를","개의","개정된","개체를","개체와","객체","객체(여기에서는","객체.","객체가","객체는","객체들을","객체라고","객체로","객체를","객체마다","객체만","객체에","객체에는","객체에서","객체와","객체의","객체인","객체인지","객체입니다.","객체입니다:","객체지향","객쳬지향","갯수가","거대한","거라","거라고","거슬러","거의","거쳐","거치며","걱정을","걱정하지","걱정할","건","건너","건너뛰기[default","건너뛸","건너뜁니다.","건전성","건전성에","건전하지","걸","걸쳐","걸프","걸프,","검사","검사,","검사가","검사기","검사기를","검사는","검사되므로,","검사되지","검사된","검사로","검사를","검사에","검사에는","검사와","검사의","검사하기","검사하는","검사하면","검사하여","검사하지","검사한다는","검사할","검사합니다","검사합니다,","검사합니다.","검사합니다:","검사해야","검색","검색하세요","검색할","검색합니다.","검이라고","검증하기","검증하는","검증해야","겁니다.","겁니다:","겁니다;","것","것과","것과는","것도","것도)과","것들에는","것들은","것들을","것들의","것들이","것만","것만으로도","것보다","것부터","것뿐만","것뿐입니다.","것에","것에는","것에도","것으로","것은","것을","것이","것이고","것이고,","것이기","것이다.","것이든","것이라는","것이라도","것이라면,","것이며","것이며,","것이므로","것이었습니다.","것이지만,","것인지를","것입니까?","것입니다","것입니다!","것입니다).","것입니다,","것입니다.","것입니다.entri","것입니다.각","것입니다.다행히도","것입니다.대신","것입니다.이는","것입니다.종종","것입니다.즉","것입니다.첫","것입니다.파일이","것입니다:","것입니다;","것입니다만,","것처럼","것처럼,","게","게다가,","게시물에서는","격리를","결과","결과가","결과는","결과를","결과물은","결과물을","결과물의","결과적으로","결정.","결정되거나","결정되거나,","결정되는","결정되면,","결정됩니다","결정됩니다.","결정됩니다:","결정하기","결정하는","결정할","결정합니다.","결정해야","결함을","결합","결합(union)을","결합되어","결합된","결합될","결합됩니다.","결합을","결합하면","결합하여","결합한","결합할","결합합니다.","결합해","겹쳐질","경고","경고가","경고를","경고합니다.","경고합니다.이","경로","경로.","경로가","경로는","경로로","경로를","경로에","경로와","경로의","경로일","경보","경우","경우)","경우)인","경우,","경우.","경우:","경우가","경우는","경우라면,","경우를","경우를,","경우에","경우에,","경우에는","경우에도","경우에만","경우엔","경우와","경우입니다.","경향이","경험","경험을","계산기","계산기를","계산기의","계산되지","계산된","계산됨)","계산할","계산합니다.","계속","계속해서","계약(contract)을","계약을","계층","계층과","계층에","계층에서","계층을","계층적","계층적으로","계획이라면","고급","고급스럽게","고려","고려됩니다.","고려하세요.","고려하여","고려하지","고려할","고려해봅시다.","고려해야","고려했으며,","고를","고립성과","고맙게도,","고유하지","고유한","고유해야","고정되는","고정된","고치기","고치도록","고침","고통스러운","고품질의","골격으로","곳과","곳에","곳에나,","곳에서","곳에서도","곳으로","곳을","곳이","곳입니다.","공간(valu","공간에","공개","공개된","공백","공백이","공변","공식적으로","공유됩니다.","공유하기","공유하는","공유함을","공유합니다.","공통","공통된","공통성을","공통인","과","과는","과도하게","과도한","과부하","과정","과정과","과정도","과정에","과정에서","과정에서,","과정은","과정을","과정이","과제를","과하게","과하다고","관계","관계는","관계를","관계시키는","관계없는","관계없이","관계의","관대하기","관대하지","관대한","관련","관련).","관련되어","관련된","관련사항","관련이","관리되는","관리됩니다.","관리하는","관리합니다.프로젝트에","관리해야","관심","관심이","관용적입니다.","관점에서","관점에서는","관찰","관찰,","관찰하거나","관찰하는","관하여","관한","관해선,","괄호","괄호가","괄호로","괄호를","괄호화된","광범위하게","광범위한","괜찮다고","괜찮다면,","괜찮습니다!","괜찮을","굉장한","교차","교체하는","교체합니다.","교환적으로","구문","구문)","구문).","구문과","구문으로","구문은","구문을","구문이","구문일","구문입니다.","구문적으로","구별돼야","구별은","구별하기","구별할","구별합니다.","구분되는","구분된","구분에","구분하는","구분하여","구성","구성된","구성됩니다","구성됩니다.","구성에","구성은","구성을","구성하겠습니다:","구성하고","구성하는","구성하여","구성하지","구성할","구성할지","구성합니다,","구성합니다.","구성합니다:","구성해야","구애받지","구조","구조가","구조는","구조로","구조를","구조와","구조의","구조입니다.","구조적","구조적인","구조체,","구조화","구조화에","구조화하기","구조화하기에","구조화하는","구조화해야","구체적\"이면,","구체적으로","구체적인","구체적일","구축하거나","구축하는","구현","구현도","구현되기","구현되어","구현되어야","구현된","구현될","구현에","구현에서","구현에서,","구현은","구현을","구현이","구현입니다.","구현체로","구현하고","구현하기","구현하는","구현하더라도","구현하여","구현할","구현합니다.","구현해","구현해놓지","구현해야","국제화","굳이","궁금할","권장되지는","권장됩니다.","권장하는","권장하지","권장합니다.","권한의","귀찮습니다.","귀찮은","규모가","규모에서","규칙","규칙과","규칙들을","규칙에서","규칙엔","규칙은","규칙을","규칙이","규칙입니다.","균등","그","그것의","그냥","그대로","그동안,","그들은","그들의","그들이","그래서","그러고","그러나","그러나,","그러면","그러므로","그러한","그런","그런데,","그런트","그럼에도","그렇게","그렇다면,","그렇듯,","그렇습니다),","그렇지","그레이션에는","그룹","그룹을","그룹의","그룹화하는데","그리고","그리고,","그만두면,","그에","그중","글","글로벌","글에서는","글은","글을","금방","급격한","기계적으로","기꺼이","기능","기능과","기능도","기능에","기능으로","기능은","기능을","기능이","기능이지만","기능입니다.","기다려서","기다리며)","기다릴","기대하는","기대하지","기대할","기대해도","기대했던","기록하는","기록하도록","기록할","기명","기반","기반으로","기반으로,","기반의","기반입니다.","기반한","기반해서","기법","기법들을","기본","기본값","기본값,","기본값과","기본값를","기본값으로","기본값은","기본값을","기본만","기본이","기본적으로","기본적으로(위에서","기본적으로,","기본적으로는","기본적인","기본적인(위에서","기술들로","기술을","기술적으로","기술하기","기술하는","기술하는데","기술하지","기술할","기술합니다.","기억을","기억하기","기억하나요?","기억하는","기억하세요.","기억하세요:","기억하십시오.","기억한다면","기억해야","기여","기여하고,","기여할","기존","기존에","기존의","기존의javascript로","기준):","기준으로","기초","기초적인","기초클래스에서","기타","기회입니다:","길이를","길이와","깊게","깊이","깊이.","까다로울","깔끔하고","꺾쇠","꺾쇠괄호(<>)","꺾쇠괄호(<>)에","꽤","끌어내려고","끌어낼","끝난","끝납니다.","끝냈나요?","끝에","끝의","나","나눌","나뉩니다:","나란히","나머지","나머지는","나머지를","나면,","나서","나서,","나아가서,","나열","나열되는,","나열되어","나열된","나열합니다.","나열해야","나오거나,","나오는","나온","나옵니다:","나와있습니다.","나은","나중까지","나중에","나중에는","나중의","나타나기","나타날","나타납니다.","나타내고","나타내기","나타내는","나타내지","나타낼","나타냅니다.","나타냅니다.tsconfig.json","난","난독화로","남겨놓겠습니다","남깁니다.","남아있는","남은","납니다.","낮은","낳을","내","내가","내는","내려야","내보내거나","내보내기","내보내기는","내보내는","내보내지","내보낸","내보낼","내보냄","내보냅니다.","내보냅니다.소스","내부","내부를","내부에","내부에,","내부에서","내부의","내에","내에서","내에서는","내에서만","내용:","내용물이","내용은","내용은,","내용을","내용의","내의","내장","내장되어","내장된","내장형","내재적으로","내재한","낼","냅니다.","너무","너무나","널러블","널리","넓은","넘겨","넘겨주는","넘겨주면,","넘겨주지","넘겨줄","넘겨지는","넘겨지는데","넘기면","넘긴다고","넘길","넘는","넘어,","넘어가겠습니다.","넘어갈","넘어선","넘어오는","넣는","넣어","넣어서","넣어야","넣으면","넣을","네이밍","네이티브","네임","네임스페이스","네임스페이스(타입","네임스페이스,","네임스페이스가","네임스페이스는","네임스페이스도","네임스페이스라는","네임스페이스로","네임스페이스를","네임스페이스에","네임스페이스에서","네임스페이스에서만","네임스페이스와","네임스페이스와는","네임스페이스의","네임스페이스입니다.","네임스페이스화된","노드","노드에서","노드와","노드입니다.","노력을","노력하고","노출","노출되며","노출된","노출하기","노출하는","노출하므로","노출합니다.","노출합니다:","노트에","논리적","논리적으로","논의한","놀라운","놀란","놀랍게도","놀랐더라도","높습니다.","높은","높을","높이지","높일","높입니다.","놓을","누구나","누군가의","누락된","누락됨","누르고","누릴","누수를","눈치챘을","눌러","눌러도","느껴질","느꼈습니다.","느끼실","느낄","느려질","느리게","느슨하면","느슨한\"","느슨함","는","능력을","다","다는","다루게","다루겠습니다.","다루기","다루는","다루도록","다룰","다룹니다.","다뤄보겠습니다.","다뤄지도록","다뤘던","다르게","다르게,","다르기","다르다'입니다.","다르다는","다르며,","다르지","다르지만","다르지만,","다른","다릅니다!","다릅니다.","다릅니다:","다소","다수의","다시","다양하기","다양한","다운","다운로드","다운로드.","다운로드할","다음","다음,","다음과","다음에","다음으로","다음으로,","다음은","다음은greeter","다음을","다음의","다음처럼","다이얼로그와","다중","다할","다행히","다행히,","다행히도","다형성","단","단,","단계","단계(예:","단계가","단계는","단계를","단계에서","단계에서만","단계입니다.","단서","단순하다는","단순한","단순화할","단순히","단언","단언(type","단언,","단언과","단언만","단언에는","단언은","단언을","단언하기","단언합니다.","단위가","단일","단점","단점들에","단점입니다.","단지","단축어처럼","단항","닫힌","달거나","달라집니다.","달리","달리).","달리,","달성하기","달아","담아","답은","당신","당신은","당신의","당신이","당연히","당장은","대개,","대게","대괄호로","대규모","대답해","대로","대로,","대문자로","대부분","대부분은","대부분의","대상","대상들이","대상에","대상에서","대상으로","대상으로한,","대상을","대상의","대상이","대상이며","대수적","대신","대신)","대신,","대신에","대신에,","대신해서","대신해주지","대안","대안:","대응되는","대응인","대응입니다.","대응하기","대조적입니다.","대체","대체로","대체의","대체하는","대체하려면,","대체하세요:","대체할","대하여","대한","대해","대해서","대해서는","대해서도","대해서만","더","더는","더불어,","더욱","더욱이","더해보겠습니다.","더해질","덕분에","던질","덜","덜어주기","덧붙이는","덮어쓰기","덮어쓰기도","덮어쓰는","덮어쓰는데,","덮어쓰지","덮어쓸","덮어씁니다.","데","데로","데만","데에","데이터","데이터.","데이터는","데이터를","데이터베이스","데이터와","데이터의","데이터이며","데코레이터","데코레이터가","데코레이터는","데코레이터를","데코레이터에","데코레이터에서","데코레이터와","데코레이터의","데코레이팅","데코레이팅된","도","도구","도구는","도구들","도구를","도구만","도구뿐만","도구상자의","도구와","도구의","도구입니다.","도달","도달할","도메인에","도와줄","도와줍니다.","도우미","도움말을","도움을","도움이","도입됨에","도입됩니다:","도입하게","도입하는","도입하지","도입했습니다.","독립적입니다.","독립형","독특한","돌아가기","돌아가서","돌아가서,","돌아와서","동시에","동안","동안에는","동의어이기","동일","동일하게","동일하다고","동일하다는","동일하며","동일하지만","동일하지만,","동일한","동일합니다.","동일합니다:","동일해야","동작","동작,","동작과","동작에","동작에서","동작은","동작을","동작의","동작이","동작이며,","동작이므로,","동작하게","동작하고","동작하는","동작하는지","동작하도록","동작하려면","동작하며","동작하며,","동작하므로","동작하지","동작하지만,","동작합니다","동작합니다.","동작합니다:","동적","동적으로","동적이고","동적인","동형","동형이","동형이지만","됐습니다.","되고","되고,","되기","되기도","되는","되도록","되며,","되면","되면,","되므로","되어야","되어있다는","되었는데,","되었습니다!","되었습니다.","되었으니,","되지","되지만,","된","된다는","된다면","된다면,","될","될것입니다.","될만한","될수록","될지라도","됨","됩니다.","됩니다.js에서","됩니다:","두","두개의","두고","두고\"십억","두는","두려워하지","두면","두번째는","두세요","두었다는","두었습니다.","두지","둔다면","둘","둘러싸서","둘은","둘을","둘의","둘째,","둡니다.","뒤따라","뒤따라오는","뒤따르는","뒤에","뒤에있는","뒤의","드물지만","들면","들면,","들면:","들어","들어,","들어:","들어가고","들어가기","들어간","들어갈","들어보겠습니다:","들어있는","등","등)","등).","등)가","등)는","등.)","등..)","등과","등록","등록할","등으로","등은","등을","등의","등장합니다:","등장했습니다.","디렉터리","디렉터리,으로","디렉터리가","디렉터리는","디렉터리로","디렉터리를","디렉터리부터","디렉터리에","디렉터리에게","디렉터리의","디렉토리","디렉토리.","디렉토리가","디렉토리는","디렉토리로","디렉토리를","디렉토리부터","디렉토리에","디렉토리에서부터","디렉토리에의","디렉토리와","디렉토리의","디렉토리입니다.","디렉티브를","디버거가","디버거를","디버그","디버깅","디버깅을","디버깅이","디버깅하고","디버깅하는","디버깅할","디자인","디폴트","디폴트는","따라","따라,","따라서","따라서,","따라야","따르는","따르면,","따른","따를지","따릅니다,","따릅니다.","따릅니다:","때","때)","때,","때:","때가","때까지","때나","때는","때는,","때도","때때로","때로는","때를","때마다","때마다,","때만","때문","때문에","때문에),","때문에,","때문이고,","때문입니다","때문입니다)","때문입니다.","때문입니다:","때에","때에만","때와","때의","때입니다.","때입니다:","떠올려","또","또는","또는,","또는symbol","또는tsconfig.json에서","또다른","또한","또한,","똑같이","뛰어난","뛸","뜻이고,","뜻인지","뜻합니다.","뜻합니다:","띄울","라고","라는","라면,","라벨에","라벨은","라이브러리","라이브러리(예.lib.d.ts)를","라이브러리가","라이브러리는","라이브러리들은","라이브러리들의","라이브러리라고","라이브러리로","라이브러리를","라이브러리에","라이브러리에서","라이브러리와","라이브러리의","라이브러리입니다.","라인","라인에","라인에서","라인에서는","라인의","라인이","라인이나","래핑","런타임","런타임시","런타임에","런타임에도","런타임에서","런타임에서,","런타임에서는","런타임에서도","런타임엔","런타임은","런타임을","런타임의","레벨","레벨로","레벨에","레벨에서","레벨에서만","레벨에서의","레벨의","레벨이거나,","레이블에","레이아웃","레이아웃과","레이아웃은","레이아웃을","레이아웃이","레이어가","레이어를","레퍼런스","레퍼런스를","렉시컬","로","로\"","로그","로그가","로그를","로그에","로그했습니다.","로깅을","로더","로더(예:","로더가","로더는","로더로","로더로는","로더를","로더보다","로더에","로더에서","로더에서,","로더에서는","로더와","로더의","로더인","로드","로드되는지","로드되므로(모듈","로드되어야","로드된","로드됩니다.asp.net","로드하기","로드하기에서","로드하는","로드하도록","로드하려는","로드하여","로드할","로딩","로딩과","로직","로직은","로직을","로컬","로컬에","로컬에서","로케일","로케일에","로케일을","루트","루트가","루트에","루트임을","루프","루프가","루프는","루프를","루프에","루프의","루프입니다:","를","리눅스에서","리눅스와","리다이렉트합니다.","리뷰를","리스트","리스트가","리스트를","리스트에서","리스트에서도","리스팅을","리액트","리액트를","리액트에서","리액트에선","리액트와","리터럴","리터럴)","리터럴과","리터럴과는","리터럴도","리터럴로","리터럴에","리터럴에서","리터럴은","리터럴을","리터럴의","리터럴이","리터럴이어야만","리턴","리팩토링을","리팩토링해야합니다.","릴리스에서","릴리즈","마법을","마세요","마세요!","마세요!)","마세요.","마세요:","마우스","마우스를","마이","마이그레이션","마자막으로,","마주치는","마주할","마지막","마지막에","마지막엔","마지막으로","마지막으로,","마찬가지).","마찬가지로","마찬가지로,","마찬가지입니다.","마찬가지입니다.여기에서.","마찬가지입니다:","마찰을","마찰이","마치","마침","마커","막기","막는데","막대","막지는","만","만드는","만든","만들","만들겠습니다.","만들고","만들고,","만들기","만들려고","만들면,","만들수","만들어","만들어낼","만들어보겠습니다.","만들어야","만들어졌으며","만들어지는","만들어진","만들어집니다","만들었습니다.","만들지","만듭니다","만듭니다,","만듭니다.","만듭니다:","만약","만약에","만큼","많거나","많습니다!)","많아집니다.","많으며,","많은","많음","많이","말로","말씀드리자면,","말아야","말은,","말입니다),","말하려는","말하면,","말하자면,","말할","말합니다.","말해,","말해서","말해주는","말해주듯이,","말했듯이,","맞게","맞는","맞는지만","맞닥뜨리면","맞지","맞추고","맞추기","맞추어","맞춤형","매","매개","매개변수","매개변수(...nums)를","매개변수(예:","매개변수.","매개변수가","매개변수끼리","매개변수는","매개변수도","매개변수든","매개변수들은","매개변수들의","매개변수들이","매개변수라고","매개변수라는","매개변수로","매개변수를","매개변수만","매개변수만을","매개변수보다","매개변수에","매개변수에도","매개변수와","매개변수와는","매개변수의","매개변수인","매개변수입니다.","매개변수처럼","매겨진","매기도록","매깁니다.","매니저","매니저)","매번","매우","매칭","매칭되는지","매핑","매핑과","매핑도","매핑된","매핑됩니다.","매핑시키는","매핑에","매핑으로","매핑은","매핑을","매핑의","매핑이","매핑하기","매핑하는","맨","맵","맵(maps)으로","맵과","맵에","맵으로","맵을","맵이","맵핑","맵핑이","머뭇거릴","먼저","먼저,","멈추고","멈추는","메개변수","메모리","메서드","메서드(mutat","메서드,","메서드가","메서드는","메서드들은","메서드로","메서드를","메서드에","메서드에도","메서드에서","메서드와","메서드의","메서드입니다.","메세지","메세지를","메소드object.prototype.tostring로","메시지가","메시지는","메시지로","메시지를","메인","메커니즘","메커니즘에","메커니즘을","메커니즘이","메타","메타데이터","메타데이터를","멤버","멤버(이","멤버,","멤버가","멤버는","멤버도","멤버들에","멤버들은","멤버들의","멤버들이","멤버로","멤버를","멤버만","멤버만으로","멤버보다는","멤버에","멤버에도","멤버에만","멤버와","멤버의","멤버이기","멤버이므로","멤버일지라도,","멤버입니다.","명령","명령과","명령문을","명령어로","명령줄","명령줄:","명령줄로","명령행","명명된","명목적","명백해집니다.","명시되어","명시되지","명시적(또는","명시적으로","명시적인","명시적일","명시하는","명시하려면","명시할","명시합니다:","명시해","명심하세요","명심하세요:","명심하세요;","명심하시길","명심해야","명확하게","명확하게하기","명확하고","명확하지","명확한","몇","몇가지","몇몇","몇몇은:","몇몇의","모델링","모델링하는데","모델링할","모델에서","모델은","모두","모두,","모두가","모두를","모두보다는,","모듈","모듈'이라고","모듈(ambient","모듈)의","모듈,","모듈과","모듈군","모듈당","모듈도","모듈들을","모듈들의","모듈들이","모듈로","모듈로부터","모듈만","모듈에","모듈에는","모듈에도","모듈에서","모듈은","모듈을","모듈의","모듈이","모듈이나","모듈이라고","모듈인지","모듈임을","모듈형","모드","모드는","모드들은","모드로","모드를","모드에서는","모드에서는,","모드와","모든","모르거나","모르는","모를","모릅니다.","모방,","모방하려고","모방합니다.","모습을","모습이","모아서","모을","모호해","목록","목록.","목록과","목록보기","목록에","목록에서","목록에서만","목록으로","목록은","목록을","목록의","목록이고","목록입니다.","목록입니다.가능한","목록입니다:","목록처럼","목적","목적에","목적은","목적을","목적이","목차","몫으로","못하게","못하는","못하도록","못한","못한다면,","못할","못합니다","못합니다.","묘사하기","무관하게","무상태","무상태로","무슨","무슨일이","무시됩니다.","무시됩니다;","무시하는","무시할","무언가라면","무언가를","무엇을","무엇이","무엇이든","무엇인가?","무엇인지","무엇일까요?","무조건","무조건적인","무한으로","무한한","묵시적인","묶는","묶어서","묶인","묶지","문","문맥상","문맥에","문맥에서도","문맥적","문맥적으로","문법","문법은","문법을","문법의","문법입니다:","문서","문서는","문서를","문서에","문서에서","문서에서는","문서에서도","문서와","문서을","문서화","문서화의","문에","문에서","문으로","문은","문을","문자","문자로","문자를","문자열","문자열,","문자열과","문자열들은","문자열로","문자열에","문자열은","문자열을","문자열의","문자열이","문자열이라면,","문자열이어야","문자열입니다","문자열입니다.","문자열처럼,","문자와","문제가","문제는","문제들이","문제를","문제없는","문제없습니다.","문제없이","문제에","문제점에","묻는","물론","물론,","물리적","물음표","뭘","뭘까?\"라고","미래의","미리","미묘하지만","미묘한","미치는","미치는지","미치며,","미치지","미칩니다.","믹스에","믹스인","믹스인에","믹스인이나","믿어,","밀리","밀접하게","및","밑에서","바","바깥","바깥에서도","바꾸고","바꾸기","바꾸는","바꾸는게","바꿀","바꿀수","바꿉니다.","바꿔","바꿔야","바꿔줍니다:","바뀌지","바뀝니다.","바닐라","바람직하지","바람직하진","바랍니다.","바로","바르게","바벨","바와","바이트","바인딩","바인딩되는","바인딩에서","바인딩을","박싱된","밖에","밖에도","밖에서","반","반대","반대로","반대로)를","반대여도","반대입니다.","반드시","반면","반면,","반면에","반면에,","반복","반복되는","반복될","반복마다","반복자","반복자는","반복자를","반복적으로","반복할","반복합니다.","반복합니다;","반영되지","반영하기","반영하도록","반영합니다.","반영해야","반환","반환값을","반환값이","반환되는지","반환된","반환된다는","반환될","반환문을","반환문이","반환하거나","반환하거나,","반환하고,","반환하기","반환하는","반환하도록","반환하면","반환하면,","반환하지","반환한다.\"라고","반환한다고","반환할","반환합니다","반환합니다.","반환했다면,","받게","받고","받고,","받기","받는","받는것","받습니다.","받아","받아들일","받아서","받았습니다:","받은","받을","받지","발견되는","발견하는","발견할","발생","발생:","발생시키거나","발생시키지","발생시킬","발생시킵니다","발생시킵니다.","발생으로","발생하기","발생하는","발생하도록","발생하며","발생하면","발생하면,","발생하지","발생한","발생한다는","발생할","발생함을","발생합니다.","발전시켜","발췌)","방금","방문할","방문해","방법","방법\"","방법,","방법과","방법과,","방법대로라면","방법에","방법에는","방법으로","방법으로,","방법으로도","방법은","방법은,","방법을","방법의","방법이","방법이며,","방법이지만","방법이지만,","방법입니다.","방법입니다:","방생되어","방식과","방식들과","방식들이","방식에","방식으로","방식은","방식을","방식이며,","방식입니다.","방정식의","방지","방지\"","방지하고","방지하기","방지하는","방지하면서,","방지할","방지합니다.","방출","방출되는","방출된","방출에는","방출을","방출하지","방출합니다.","방출했습니다.이","방해합니다.","방향\"에서도","방향은","배열","배열:","배열과","배열로","배열에","배열에서","배열은","배열을","배열의","배열이","배열이나","배열인","배열처럼","배우고,","배우진","배울","배워","배워보겠습니다.","배웠습니다.","배치","배포","배포되었습니다.","배포됩니다.다음과","배포하기","배포하는","배포하려면,","배포할","백","백그라운드","백업","백틱/백쿼트","버그가","버그는","버그를","버그의","버그이지만","버그입니다.","버리게","버립니다.","버전","버전:","버전과의","버전부터,","버전에서","버전에서,","버전에서는","버전으로","버전은","버전을","버전의","버튼으로","벅차다고","번","번들","번들러(예.","번들러내에서의","번들로","번들링","번들링과","번들링된","번들링을","번들링이나","번들링하거나","번들을","번만","번에","번역","번역,","번역가이드","번역됩니다.","번역하는","번째","번째,","번째는","번째로","번째로,","번째에","번형도","번호를","벌어질까요?","범위로","범위를","범위에","범위에서","범위의","법칙은","벗겨진","벗어나는","베열","베이스를","베이스에서","베이스에서는,","변(contra","변경","변경),","변경,","변경되든","변경되지","변경된","변경될","변경사항을","변경에","변경은","변경을","변경의","변경이","변경하고","변경하는","변경하면,","변경하십시오","변경하여","변경하지","변경할","변경합니다","변경합니다.","변경합니다.이제","변경해","변경해야","변경했습니다.편리하게도","변동성이","변수","변수)","변수,","변수가","변수나","변수는","변수들에","변수들은","변수들을","변수들이","변수로","변수로도","변수를","변수에","변수에는","변수에도","변수에서","변수와","변수의","변수입니다.","변하지","변형된","변형시킵니다.","변형을","변형이","변형입니다.","변형하지","변형한","변화가","변화를","변화에","변환","변환(형","변환)과","변환도","변환되는","변환되어야","변환을","변환의","변환이","변환하기","변환하는","변환하려는","변환한","변환할","변환합니다","변환합니다.","변환해봅시다.","별","별개의","별도로,","별도의","별로","별칭","별칭)","별칭)를","별칭,","별칭과","별칭보다","별칭으로","별칭은","별칭을","별칭이라고","별칭인","별칭입니다:","병합","병합\"은","병합'","병합(merge)","병합:","병합되는","병합되며,","병합되어","병합되지","병합된","병합됩니다.","병합됩니다:","병합은","병합을","병합의","병합이","병합입니다.","병합하기","병합하는","병합하는지","병합하려면,","병합하십시오","병합할","병합합니다.","보간하여","보강","보강과","보강된","보강에","보강을","보강하는","보강하지는","보강할","보게해야","보겠습니다.","보겠습니다.이것은","보겠습니다:","보고","보고된","보고를","보고하며","보고하지","보고할","보고합니다.","보고합니다.상속","보기","보냅니다","보는","보다","보단","보도록","보려면","보려면,","보면","보면,","보세요.","보세요:","보수가","보신","보실","보십시오.","보십시오:","보았다면,","보았을","보여주고,","보여주기","보여주는","보여주지만","보여줄","보여줌","보여줍니다","보여줍니다.","보여줍니다:","보이는","보이는지","보이지","보이지만,","보일","보일러","보입니다.","보입니다:","보장되는","보장하는","보장하는데","보장할","보장합니다.","보존될","보존하며","보존하지만,","보존합니다.","보통","보통의","복사되어","복사를","복사본에","복사하거나,","복사하는","복사하세요.","복사하여","복사하지","복사할","복사합니다.","복사해야","복잡하지","복잡한","복잡합니다.","복잡해집니다.","본","본론으로","본문","본문에","본문에서","본문을","본문의","본문이","본인에게","본인의","본질적으로","볼","볼까요:","봅시다.","봅시다:","봐야","부동","부르겠습니다.","부를","부릅니다.","부분","부분들이","부분에","부분에서","부분에서는","부분으로","부분은","부분을","부분의","부분이며,","부분입니다,","부분입니다.","부분적으로","부분적인","부분집합을","부분클래스를","부수효과만을","부여합니다.","부울입니다.","부족하거나/혹은","부족하여","부터","부호","부호는","분기","분기가","분기를","분기에서","분기에서는","분들은","분들을","분들이라면","분리되어","분리된","분리해서","분리해야","분명히","분산","분산되었는지","분산된","분산됩니다.","분석","분석을","분석하기","분할","분할하는","분할합니다.","분할해야","분해","분해가","분해는","분해된","분해될","분해됩니다;","분해를","분해와","분해의","분해입니다.","분해처럼,","분해할","불가능하다는","불가능한","불가능할","불가능합니다.","불과합니다.","불구하고","불러오기","불렸습니다.","불리기도","불리는","불리언","불리언(boolean)에는","불리하여","불문하고","불변이라고","불변하다고","불변하며","불짜리","불평하는","불필요한","불필요합니다.","불행하게도,","불행히도","불확실한","붙습니다.","붙어야","붙여","붙여야","붙여줄","붙여집니다.","붙였으니,","붙이겠지만","붙이는","붙이더라도","붙임으로써","붙입니다.","붙입니다.반면,","붙혀집니다.","붙히는","뷰는","브라우저","브라우저가","브라우저는","브라우저로","브라우저에서","브라우저와","브랜치에서","브랜치의","브레이크포인트가","브레이크포인트을","블랙박스입니다.","블록","블록과","블록까지로","블록에","블록으로","블록은","블록의","비","비공개","비공개(hard","비공개(soft","비공개가","비공개는","비공개로","비공개를","비공개와","비공개이기","비교","비교될","비교됩니다.","비교를","비교적","비교하는","비교할","비롯된","비밀스러운","비슷하게","비슷하게,","비슷하지만","비슷하지만,","비슷한","비슷합니다).","비슷합니다.","비슷합니다만,","비어있는","비어있을","비용을","비워","비워두는","비활성화할","비활성화합니다.","빈","빈번할","빌드","빌드)","빌드가","빌드간에","빌드는","빌드를","빌드에","빌드의","빌드하는","빌드하여","빌드한","빌드합니다.","빠르게","빠른","빠를","빠진","빨간","빨간선이","빨리","빼고는","빼먹는","뻬먹지","뼈대로","뼈대를","뽑아내는","뿐만","뿐입니다.","사라지고","사라지려면","사람들에게","사람들은","사람들이","사람이라면,","사례","사실","사실만","사실상","사실을","사양에","사양을","사용","사용)","사용.","사용:","사용되거나,","사용되는","사용되는지","사용되도록","사용되며","사용되지","사용된","사용된다면","사용될","사용될수","사용됨","사용됨.","사용됩니다.","사용됩니다.지원되는","사용됩니다:","사용법","사용법과","사용법은","사용법이","사용에","사용으로부터","사용은","사용을","사용자","사용자가","사용자는","사용자들에게","사용자들에게,","사용자들의","사용자들이","사용자로부터","사용자로부터도","사용자를","사용자에게","사용자에게는","사용자에겐","사용자의","사용하거나","사용하겠지만","사용하고","사용하고,","사용하기","사용하기\"","사용하기가","사용하기로","사용하기에서","사용하길","사용하느냐에","사용하는","사용하는데,","사용하는지","사용하는지는","사용하던","사용하도록","사용하려","사용하려는","사용하려면","사용하면","사용하면,","사용하세요","사용하세요.","사용하세요:","사용하세요;","사용하셔야","사용하십시오.","사용하여","사용하여,","사용하지","사용하지만","사용하지만,","사용한","사용한다고","사용한다면","사용한다면,","사용할","사용할지","사용할지는","사용함으로써","사용합니다","사용합니다,","사용합니다.","사용합니다.\"react\"","사용합니다.package.json","사용합니다.기본","사용해","사용해도","사용해보겠습니다:","사용해본","사용해봤다면,","사용해서","사용해야","사용해야할","사용했고,","사용했다는","사용했던","사용했습니다.","사용했습니다:","사용했지만","사용했지만,","사이드","사이에","사이의","사이즈","사이클을","사항","사항:","사항에","사항에는","사항에서","사항은","사항을","사항이","사항이라는","사항이므로","사항이지만","사항임","살펴","살펴보겠습니다.","살펴보겠습니다.새로운","살펴보겠습니다:","살펴보겠지만,","살펴보고","살펴보도록","살펴보세요.","살펴보았습니다.","살펴볼","살펴봅니다.","살펴봅시다:","삶의","삽입됩니다.","삽입하는","상관없다는","상관없습니다;","상관없이","상급","상기해봅시다.","상단에서","상단에서만","상당히","상대","상대적","상대적으로","상대적이거나","상대적이냐에","상대적이라고","상대적이라면","상대적이면,","상대적인","상대적임.","상상할","상세","상속","상속계층을","상속되는","상속된","상속받고","상속받고,","상속받습니다.","상속받을","상속받지","상속받지만","상속을","상속하는","상속하여","상속할","상속해서","상수","상수들의","상수로","상수이거나","상수입니다.","상수입니다:","상위","상위클래스(superclasses)","상응하는","상의","상의하세요.","상자에","상태\"의","상태는","상태로","상태를","상태에서","상호","상호작용할","상황","상황마다","상황에","상황에서","상황은","상황을","상황이","새","새로","새로고침","새로운","색상","색인(ordin","색인화(indexed)되면","샘플","샘플:","샘플에서","생각하는","생각하면","생각하여","생각하지","생각할","생각합니다.","생각해","생각해보세요.","생각해보세요:","생각해보세요;","생각해볼","생각해봅시다.","생각해봐야","생각해야","생각해야합니다.word에서","생긴","생깁니다.","생략","생략될","생략할","생성","생성기에","생성되는","생성되었습니다.","생성된","생성될","생성됩니다.","생성됩니다:","생성자","생성자가","생성자는","생성자를","생성자에","생성자에서","생성자와","생성자의","생성자이고","생성하거나,","생성하겠습니다:","생성하고","생성하고,","생성하기","생성하기위해","생성하는","생성하려고","생성하세요.","생성하여","생성하여,","생성하였고,","생성하지","생성한","생성할","생성함으로써","생성합니다","생성합니다,","생성합니다.","생성합니다:","생태계를","서로","서명","서명(string","서명에","서명은","서명을","서명이","서버","서브","서브클래싱을","서브타이핑","서비스","서비스에","서수","서술어","서술어는","서술어를","서술어인","서술어입니다.","섞어서","섞인","선언","선언(shorthand","선언(type","선언,","선언과","선언도","선언되기","선언되는","선언되어","선언되어야","선언되었다고","선언되었을","선언되었음을","선언되었지만","선언되지","선언된","선언될","선언됩니다.","선언들은","선언만","선언문","선언문을","선언부에","선언에","선언에는","선언에서","선언에서,","선언에서는,","선언에서도","선언으로","선언으로도","선언으로부터","선언은","선언을","선언의","선언이","선언입니다.","선언하고","선언하기","선언하는","선언하는지는","선언하려면,","선언하며;","선언하면","선언한","선언할","선언합니다.","선언해야","선언했습니다.","선언했을","선언형입니다;","선택","선택된","선택됩니다.","선택사항","선택을","선택입니다.","선택적","선택적,","선택적으로","선택적으로,","선택적이고,","선택적이라는","선택적이어야","선택적인","선택적일","선택하고","선택하기","선택하기보단","선택하는","선택하면","선택하므로","선택하세요.","선택하여","선택하지","선택한","선택할","선택합니다.","선택합니다:","선택해","선택해야","선호되는지를","선호에","선호하는","선호해야","설계","설계되었습니다.","설명","설명되어","설명된","설명은","설명을","설명자","설명자(properti","설명자가","설명자는","설명자로","설명자에","설명자의","설명하고","설명하기","설명하는","설명하려면,","설명하므로,","설명한","설명한다는","설명한대로)","설명할","설명합니다.","설명해","설명해야","설명했던","설정","설정되면","설정되어","설정되었기","설정되었다고","설정되지","설정된","설정될","설정시","설정에","설정에서","설정은","설정을","설정이","설정하기","설정하는","설정하며,","설정하면","설정하면,","설정하세요.","설정하여","설정하지","설정한","설정할","설정합니다","설정합니다.","설정해야","설정했기","설정했다면,","설치","설치가","설치되어","설치되었으므로","설치된","설치를","설치하거나","설치하고,","설치하기","설치하는","설치하며,","설치하십시오","설치하십시오.gulp","설치하십시오.tsify는","설치하십시오.uglify의","설치하십시오.uglify처럼","설치하지","설치한","설치할","설치합니다.","설치합니다.이","설치해야","설치했다는","성공","성공,","성공적으로","성공합니다.","성능을","성분으로","성분을","성을","성질입니다.","세","세계에","세로","세밀하게","세부","세션을","세트가","세트를","세트에","섹션","섹션들로","섹션에","섹션에서","섹션에서는","섹션은","섹션을","섹션의","섹션이","소개","소개(introduction)","소개되었고,","소개된","소개합니다.","소문자로","소비","소수","소수에는","소수의","소스","소스가","소스는","소스를","소스맵을","소스에","소스의","소위","소프트웨어","소프트웨어의","속기","속도","속도가","속성","속성,","속성에","속성은","속성을","속성의","속성이","속성처럼","속하지","손쉽게","손으로","수","수가","수고가","수는","수단이","수도","수동으로","수를","수없는","수에","수와","수월하게","수의","수정","수정된","수정될","수정하기","수정하는","수정하려는","수정하면:","수정하여","수정하지","수정할","수정합니다.","수정합시다","수정해봅시다.","수정해서","수정해야","수준에서,","수준을","수준의","수집하는데","수학의","수행","수행된","수행됩니다.","수행하는","수행하면,","수행하지","수행한","수행한다는","수행할","수행합니다.","수행했다고","숙련된","숙제","순서","순서는","순서대로","순서로","순서를","순서표(bom)를","순수한","순차적으로","숫자","숫자,","숫자.","숫자/문자열","숫자나","숫자는","숫자라면,","숫자로","숫자를","숫자만으로는","숫자만큼의","숫자여야","숫자와","숫자입니다","숫자형","쉐도잉","쉬운","쉬울","쉬워","쉬워졌습니다.","쉬워집니다.","쉼표로","쉽게","쉽기","쉽습니다.","쉽습니다.typescript에서","쉽습니다:","스니펫을","스스로","스왑","스위치","스칼라","스코프","스코프가","스코프는","스코프라고","스코프로","스코프에","스코프에서","스코프의","스코프인","스코프입니다.","스코핑(block","스코핑(lexic","스크립트","스크립트가","스크립트는","스크립트로","스크립트를","스크립트에","스키마","스키마는","스타일","스타일로","스타일을","스타일의","스타일이","스타트","스태틱","스태틱과","스태틱이기","스텝","스텝은","스텝이","스페이스","스프레드","슬래시","슬래시(tripl","승인하고","시","시간","시간에","시간을","시간이","시간입니다.","시그니처","시그니처(있는","시그니처)을","시그니처가","시그니처는","시그니처라는","시그니처로","시그니처를","시그니처에","시그니처에서","시그니처와","시그니처의","시그니처인","시나리오","시나리오가","시나리오를","시나리오에","시나리오와","시나리오입니다.","시도:","시도하지","시도합니다.","시도해","시마다","시스템","시스템과는","시스템보다는","시스템에","시스템에서","시스템은","시스템을","시스템의","시스템이","시스템이)","시스템이기","시스템인","시스템입니다.","시작","시작될","시작으로","시작점을","시작하겠습니다","시작하겠습니다.","시작하고","시작하기","시작하는","시작하려면","시작하면","시작하면,","시작하여","시작하여,","시작할","시작합니다.","시작합니다;","시작합시다.","시작해","시작해서","시작해야","시작했습니다!","시점에","시점에,","시점에서","시점에서도","시퀀스","시키겠지만.","시킬","시행되며,","시험용","식별되지","식별자","식별자(data","식별자가","식별자로","식별자를","식별자에","식별자이기","식별하고,","식별하기","식별하는","식별한","식별할","식별합니다","식으로,","식은","신경","신뢰할","신중하게","신호","신호입니다.","실수","실수는","실수들은","실수들을","실수로","실수를","실시했을","실용적인","실제","실제로","실제로는","실제론,","실패","실패할","실패함.","실패합니다.","실행","실행되고","실행되기를","실행되는","실행되면","실행되면서","실행되어야","실행될","실행됩니다.","실행됩니다.main.ts에서","실행됩니다;","실행을","실행이","실행하게","실행하고","실행하기","실행하는","실행하도록","실행하려고","실행하며","실행하면","실행하면)","실행하세요:","실행하십시오.","실행하여","실행한","실행할","실행합니다.","실행합니다.(다른","실행합니다:","실행해","실행해보세요!","실행해야","실험단계입니다.","실험적","실험적인","심각하게","심벌","심벌들","심벌들은","심벌들이","심벌에","심벌와","심벌은","심벌을","심벌의","심볼","심볼의","심지어","심층","싱글톤","싶다는","싶다면","싶다면,","싶습니다.","싶어도","싶으면","싶으면,","싶은","싶을","싶을지도","쌍으로","써드파티","써서","써왔던","쓰고","쓰는","쓰도록","쓰면","쓰면,","쓰여지기","쓰이게","쓰이기","쓰이는","쓰이는군요.","쓰이는지","쓰인","쓰일","쓰입니다.","쓰지","쓸","씌웁니다.","아는","아니고,","아니기","아니라","아니라;","아니라는","아니라면","아니라면,","아니면","아니지만,","아닌","아닌)","아닌지","아닐","아님을","아닙니다","아닙니다,","아닙니다.","아닙니다.(never","아닙니다.중요한","아래","아래)","아래로","아래를","아래에","아래에서","아래에서는","아래와","아래의","아랫줄은","아마","아마도","아무","아무거나","아무것도","아무것에나","아무도","아무런","아무렇게나","아예","아이디어는","아주","아직","악명","안","안내하기","안되고","안된","안됩니다","안됩니다.","안에","안에,","안에서","안에서,","안에서도","안에서의","안의","안전도","안전성(type","안전성과","안전성을","안전하게","안전하다는","안전한","안전합니다.:","안정될","안정적인","안쪽","안쪽에","않거나","않거나,","않고","않고,","않기","않기에,","않는","않는다","않는다고","않는다는","않는다면","않는다면)","않는다면,","않다고","않다는","않다면","않다면,","않도록","않습니다","않습니다)","않습니다.","않습니다.javascript","않습니다.이","않습니다:","않아","않아도","않아서","않아서,","않았기","않았는지","않았다면","않았다면,","않았습니다","않았습니다.","않았으면,","않았을","않았지만,","않으며","않으며,","않으면","않으면,","않으므로","않으므로,","않은","않은)","않은데,","않을","않을때만","않음","않음)","않음)에서","않음,","않음.","않음을","않지만","않지만,","알","알게","알게됩니다:","알고","알고리즘에","알고리즘은","알기","알다시피,","알려져","알려주기","알려주길","알려주는","알려주어","알려주어야","알려줄","알려줍니다","알려줍니다.","알려줍니다:","알려줘야","알려지고","알려진","알려진),","알리기","알릴","알림을","알립니다.","알맞게","알맞은","알아","알아\"라고","알아내기","알아낼","알아두면","알아두세요.","알아보겠습니다.","알아보기","알아보기(understand","알아보세요.","알아볼","알아야","알아차리겠지만,","알아채셨나요?","알지","암묵적으로","암시될","암시적으로","암시적이며","암시적인","암시한","압도하여,","압축되는지","압축하기","압축합니다.","앞","앞서","앞에","앞에만","앞에서","앞엔","앞의","앞쪽의","애매하고","애플리케이션","애플리케이션에","애플리케이션에서","애플리케이션에서의","애플리케이션은,","애플리케이션을","애플리케이션의","애플리케이션이","액세스","앰비언트","앱","앱에서","앱을","앱이","앵귤러","약","약간","약간은","약간의","약칭으로","양날의","양식","양식에","양식을","양질의","얕은","얘기하지만,","얘기할","어노테이션과","어노테이션을","어느","어디를","어디서","어디서든","어디서든지","어디에","어디에서","어디에서,","어디에서나","어떠한","어떤","어떻게","어려울","어려움","어렵습니다.","어렵지","어리석은","어색함을","어쨋든","억제합니다.","언급","언급하지","언급한","언급했던","언급했듯이","언급했듯이,","언래핑","언래핑(unwrap)","언어","언어들과","언어들처럼,","언어를","언어에","언어에서","언어에서,","언어에서는","언어와","언어의","언어입니다.","언어처럼","언어처럼,","언제나","언제든","언제든지","얻게","얻게됩니다.","얻고,","얻기","얻기.","얻는","얻습니다.","얻었습니다.","얻었지만,","얻을","얻지","얼마나","엄격하게","엄격한","엄격함을","엄격해","엄청","업그레이드하라는","업데이트","업데이트가","업데이트된","업데이트하기","업데이트하세요:","업데이트하십시오","업데이트하여","업데이트할","업데이트합니다.","업데이트해야","없거나,","없고","없고,","없기","없는","없는)","없다.","없다고","없다는","없다면","없다면,","없더라도","없도록","없습니다","없습니다!","없습니다).","없습니다.","없습니다.typescript에서","없습니다:","없어도","없어서","없어야","없었기","없었습니다","없었습니다.","없으며","없으며,","없으면","없으면,","없으므로","없으므로,","없을","없음","없음.","없음을","없이","없이,","없지만","없지만,","엉망으로","에","에디터","에디터에서","에디터에서,","에러","에러!","에러가","에러를","에러의","에를","에서","에서,","에서는","엔지니어링에서의","엔진","엔진을","엔진의","엔트리를","엔트리에서","엔티티를","엔티티의","여겨지고","여겨지며","여기","여기,","여기를","여기서","여기서,","여기서는","여기서도","여기선","여기에","여기에는","여기에서","여기에서,","여기에서는","여기엔","여러","여러개의","여러분을","여러분의","여부로","여부를","여부에","여전히","여태","역","역방향","역시","역할","역할을","연결","연결(pipe)","연결의","연결하는","연결하여","연결할","연결했을","연관된","연기된","연기하겠다면","연산","연산들은","연산으로","연산자","연산자는","연산자로","연산자를","연산자에","연산자입니다.","열거","열거나,","열거하고,","열거형","열거형과","열거형과는","열거형에","열거형에서","열거형으로","열거형은","열거형을","열거형의","열거형이","열거형처럼","열고","열린","열면","열어","열어보세요","열어줄","염두에","영리한","영향","영향\"를","영향을","옆에","옆에)","예","예)","예.","예:","예는","예로","예로는","예를","예상","예상대로","예상되는","예상치","예상하는","예상해","예술적으로","예시","예시:","예시는","예시로","예시를","예시에","예시에서","예시와","예약어입니다","예에서는","예와","예외).","예외가","예외를","예외사항은","예외입니다.","예입니다.","예입니다:","예전","예제","예제:","예제가","예제는","예제들","예제들에서,","예제들을","예제로","예제로,","예제를","예제를,","예제만","예제에","예제에는","예제에서","예제에서,","예제에서:","예제에서는","예제에서는,","예제에서의","예제에서처럼","예제와","예제의","예제이며","예제입니다:","예측이","예측하기","오게","오기","오는","오늘날,","오늘날에는","오던","오래된","오류","오류!","오류).","오류,","오류.","오류:","오류가","오류는","오류도","오류들을","오류로","오류를","오류이지만","오류입니다!","오류입니다.","오류입니다:","오른쪽","오른쪽,","오른쪽에","오른쪽으로","오른쪽은","오른쪽입니다:","오버라이드","오버라이드하는","오버라이드합니다.","오버라이드해서","오버라이딩","오버로드","오버로드가","오버로드는","오버로드된","오버로드로","오버로드를","오버로드만을","오버로드와","오버로드하는","오브젝트라면","오브젝트를","오염되는","오직","오타,","오프","온","온전히","올","올라가","올라가,","올라오게","올려놓고,","올려놓으면","올리면","올바르게","올바른","올바름","옮기겠습니다.여기서","옮기고","옮기면","옳다고","옵션","옵션:","옵션과","옵션들","옵션들...","옵션에서","옵션으로","옵션은","옵션은commonjs,amd,system","옵션을","옵션의","옵션이","옵션이나","와","와야","와일드카드","와일드카드가","와일드카드는","와치","와치하여","완료","완료.","완료되면","완료되었음에도","완벽하게","완성과","완성을","완전함을","완전히","완화됩니다;","왓쳐(파일","왓쳐가","왓쳐를","왓쳐와는","왓쳐의","왔기","왔는지","왜","왜냐하면","왜냐하면,","외","외부","외부로","외부로부터","외부에","외부에서","외부에서도","외부에선","외부의","외에","외에,","외에는","외에도","왼쪽에","왼쪽에서","요구","요구사항을","요구사항이","요구하는","요구하지","요구합니다.","요구했습니다.","요소","요소(예:","요소,","요소가","요소나","요소는","요소들에","요소들을","요소들의","요소를","요소에","요소와","요소의","요소입니다.","요약되어","요약하자면,","요점은","요점을","요즘에,","요청은","요청하면","요청한","용","용도가","용어가","용어를","용이하게","용이합니다.","우","우리","우리가","우리는","우리를","우리의","우선","우선순위를","우선시한다는","우선으로","우연한","운","운반할","운영체제/파일","운영체제에서","워크플로우를","원래","원래의","원래의(병합되지","원본","원본과","원본에","원시","원시형","원인이","원천이기","원치","원칙","원칙을","원하거나,","원하는","원하는대로","원하지만,","원한다면","원한다면,","원할","원합니다.","원했지만,","웹","웹사이트의","웹팩","위","위)와","위는","위로","위에","위에서","위에서,","위와","위의","위젯의","위처럼","위치","위치(즉,","위치가","위치는","위치로","위치를","위치에","위치에서","위치에서는","위치하게","위치하는","위치하지","위치한","위치할","위키","위한","위함입니다.","위해","위해,","위해서","위해서,","위해서는","위해서는,","위해서는:","위해서만","위해선","위해선,","위험","위험성","위험성과","위험성을","위험하지만,","유니언","유니언,","유니언.","유니언과","유니언에","유니언으로","유니언은","유니언을","유니언의","유니언이","유니언이나","유니언입니다.","유래된","유명","유명한","유무를","유발하는","유발할","유발합니다:","유사","유사하게","유사하게,","유사하지만,","유사한","유사합니다.","유사합니다만,","유사해야","유연한","유연함은","유연함을","유연합니다.","유용하고","유용하다는","유용하려면","유용하지","유용하지만","유용하지만,","유용한","유용할","유용합니다","유용합니다.","유용합니다.(예,","유용합니다:","유의:","유의미하고","유의미한","유의하세요","유의하세요,","유의하세요.","유의하세요:","유의하십시오.","유의하십시오;","유의할","유의합니다.","유의해야","유의해주세요","유일하기","유일하다는","유일한","유일합니다.","유저","유저가","유저들은","유저로서","유지","유지됩니다.","유지하거나","유지하고","유지하기","유지하는","유지하려면","유지하세요.","유지하지","유지하지만,","유지한다는","유지합니다.","유지했습니다.","유추됩니다.","유추하고","유추할","유틸리티","유틸리티는","유틸리티들은","유틸리티를","유형","유형과","유형에서,","유형으로","유형은","유형의","유효성","유효하지","유효한","유효합니다.","으로","은","은닉,","을","의","의견","의도","의도된","의도를","의도였을","의도하는","의도한","의도했다고","의미","의미,","의미가","의미는","의미도","의미로","의미를","의미에","의미에서","의미와","의미인지","의미입니다.","의미하기도","의미하는","의미하지만","의미한다고","의미할","의미합니다,","의미합니다.","의미합니다.watchify와","의미합니다.또한","의존성","의존성들은","의존성들을","의존성에","의존성으로","의존성은","의존성을","의존성이","의존성이나","의존적이라면:","의존적인","의존하기","의존하는","의존하세요.","의존하지","의한","의해","의해서만","이","이거나","이건","이건,","이것들로","이것들은","이것들을","이것뿐입니다.다음으로","이것에","이것은","이것을","이것이","이게","이고","이곳에","이곳에서","이곳을","이기","이나","이는","이니셜라이저(initializer)를","이니셜라이저는","이니셜라이저를","이니셜라이저에","이더라도","이동","이동하겠습니다.이를","이동하기","이동하세요)","이동하여","이동할","이득은","이득이","이들","이들은","이들을","이들이","이때","이라","이라고","이라는","이란","이러한","이런","이런,","이렇게","이렇게도","이로","이론:","이를","이름","이름(privat","이름(이","이름,","이름과","이름과는","이름들의","이름들이","이름에","이름에서","이름으로","이름으로,","이름은","이름을","이름의","이름이","이름이어야","이름이지만","이름인","이름입니다.","이면","이미","이번","이번에도","이번엔","이벤트","이벤트를","이상","이상과","이상에서","이상을","이상의","이상이고,","이상적으로","이상적으로는","이상적인","이상한","이상해","이슈를","이슈에","이슈을","이야기","이야기합니다.","이야기해보겠습니다.","이어지며","이에","이와","이외","이외에","이외에도,","이외의","이용","이용하면","이용하여","이용한","이용할","이용해","이용해서","이용했다는","이유","이유:","이유가","이유는","이유는,","이유로","이유로,","이유를","이전","이전과","이전에","이전에는","이전에는,","이전의","이전인","이점은","이점을","이점이","이제","이제,","이제는","이종","이중","이터러블","이터러블로","이터레이터와","이팩트","이하를","이해는","이해하기","이해하기가","이해하는","이해하면,","이해하여","이해한다면","이해할","이해함으로써","이해합니다.","이해해","이해해야","이후","이후부터,","이후부터는","이후에","이후에는","이후엔","익명","익명으로","익숙하다면","익숙하다면,","익숙하지","익숙한","익숙할","익숙해져야","익숙해지는데","인","인기","인기를","인데스","인덱서(indexer)를","인덱서를","인덱서블","인덱서에서","인덱서의","인덱스","인덱스가","인덱스들에","인덱스를","인덱스에","인덱스의","인덱싱","인덱싱을","인덱싱하기","인덱싱하는","인라인","인라인되지","인라인됩니다.","인라인으로","인사말","인사말을","인사말의","인사말이","인사이트를","인쇄할","인쇄해야합니다.","인수","인수,","인수가","인수는","인수로","인수를","인수만","인수에","인수와","인수의","인스턴스","인스턴스가","인스턴스는","인스턴스도","인스턴스로","인스턴스로만","인스턴스로써","인스턴스를","인스턴스마다","인스턴스만","인스턴스의","인스턴스화","인스턴스화될","인스턴스화에서,","인스턴스화하고","인스턴스화하고,","인스턴스화하면","인스턴스화할","인스턴스화해서","인식되는","인식됩니다.","인식하기","인식하는","인식하는지","인식합니다.","인용)","인용된","인자","인자가","인자들을","인자로","인자를","인자의","인지되지","인지합니다.","인터페이스","인터페이스)를","인터페이스,","인터페이스가","인터페이스나","인터페이스는","인터페이스들도","인터페이스들이","인터페이스로","인터페이스로부터","인터페이스로써","인터페이스를","인터페이스에","인터페이스에서","인터페이스에서는","인터페이스와","인터페이스의","인터페이스입니다.","인터페이스처럼","인터페이스처럼,","인해","일","일관된","일관성","일관성이","일단","일대일","일들이","일련의","일반","일반적으로","일반적으로,","일반적으로는,","일반적이고","일반적이기","일반적이라는","일반적이며,","일반적이어서","일반적인","일반적임","일반적입니다.","일부","일부가","일부는","일부로","일부로써","일부를","일부만","일부이고","일부인","일부입니다.","일수","일시","일시적으로","일어나는","일어나는지","일으키거나,","일으키겠군요","일으키지","일으킨다는","일으킬","일으킵니다.","일을","일이","일이며","일이지만,","일입니다.","일입니다.더","일종의","일찍이","일치를","일치하게","일치하고","일치하기","일치하는","일치하도록","일치하지","일치할","일치해야","일컫는","일회성","일회성인","읽거나,","읽고","읽기","읽기전용","읽기전용으로","읽도록","읽습니다","읽습니다.","읽어보세요","읽어보세요.","읽어보실","읽어볼","읽어야","읽었고","읽으실","읽은","읽을","잃게","잃어","잃으키지","잃지","임베딩,","임을","임의로","임의의","임포트","임포트와","임포트합니다.","입니다","입니다.","입니다.extends'","입력","입력과","입력받을","입력에","입력으로","입력을","입력하고","입력하고,","입력하기","입력하면","입력하면,","입력하세요:","입력하십시오","입력할","입력합니다.","입력해보세요.","입장에서는","잇습니다.","있거나","있거나,","있게","있게끔","있겠지만,","있고","있고,","있기","있는","있는데,","있는지","있는지를","있는지에","있는지와","있다.","있다고","있다는","있다면","있다면,","있더라도","있던","있도록","있듯,","있듯이,","있습니다","있습니다!","있습니다(한","있습니다).","있습니다,","있습니다.","있습니다.\"compileonsave\"는","있습니다.(해당","있습니다.:","있습니다.microsoft","있습니다.typescript를","있습니다.v","있습니다.►","있습니다.가능하면","있습니다.그러나","있습니다.그런","있습니다.그렇기","있습니다.기본","있습니다.다소","있습니다.또한","있습니다.먼저","있습니다.브라우저의","있습니다.아마도","있습니다.여기서","있습니다.예를","있습니다.이","있습니다.이러한","있습니다.이런","있습니다.이제","있습니다.자세한","있습니다.전형적으로","있습니다.페이지를","있습니다.하지만","있습니다:","있습니다;","있어","있어,","있어도","있어야","있어야합니다.","있었다면,","있었던","있었습니다.","있으나,","있으며","있으며,","있으며;","있으면","있으면,","있으므로","있으므로,","있을","있을뿐만","있음","있음)","있음)을","있음.","있음을","있지","있지만","있지만,","있지만;","잊어버렸을","잊었다면,","자기","자동","자동으로","자료형","자료형입니다.","자리에","자세한","자세히","자식","자식만","자식에","자식에게만","자식은","자식의","자신들","자신만의","자신에","자신은","자신을","자신의","자연스러운","자연스럽습니다.","자유롭게","자주","자체","자체가","자체는","자체로","자체를","자체에","자체에는","자체에서","자체와","자체의","자체적인","작고","작동","작동시키면","작동하거나","작동하는","작동하는지","작동하는지에","작동하여,","작동하지","작동하지만,","작동한다는","작동할","작동합니다.","작성","작성되고,","작성되는","작성되어","작성되었다고","작성되었다면","작성되었습니다.","작성되지","작성된","작성된다는","작성될","작성됩니다.","작성에","작성을","작성의","작성자는","작성자에게는","작성자일","작성하거나","작성하게","작성하고","작성하고자","작성하기","작성하기에","작성하는","작성하는지","작성하든","작성하려는","작성하면","작성하세요:","작성하여","작성하지","작성한","작성할","작성합니다","작성합니다.","작성합니다:","작성해","작성해보겠습니다.","작성해보세요","작성해야","작성했고","작성했다고","작성했던","작성했습니다.","작성했습니다:","작성했으므로,","작성했을","작업","작업에","작업에서","작업에서는","작업은","작업을","작업의","작업이","작업입니다:","작업하기","작업하기를","작업하는","작업할","작업해야","작용합니다.","작은","작은따옴표","잘","잘못","잘못된","잘못됨","잘한다는","잘해냅니다.","잠시,","잡기","잡는데","잡아","잡아낼","잡아두는","잡아둘","잡을","장기적","장난감","장단점)를","장애와","장에서는","장점은","장점을","재","재검사/재빌드","재검사/재빌드하지않고,","재구성하지는","재귀적으로","재귀적인","재빌드","재사용","재사용성","재사용성을","재사용하기","재사용할","재선언과","재실행하면","재정의됩니다.순환성","재정의하는","재정의할","재할당","재할당을","재할당이","재할당할","저","저장","저장된","저장하는","저장하십시오.","저장한","저장할","적게","적기","적다는","적어야","적용되고","적용되기","적용되는","적용되며","적용되지","적용된","적용됩니다.","적용됩니다:","적용하기","적용하는","적용하면,","적용한","적용할","적용해야","적은","적이","적절하게","적절하지","적절한","적합하고,","적합하다고","적합한","적합합니다.","전,","전개","전개는","전개보다","전개에","전개처럼","전개하는","전개하도록","전개하면","전개할","전까지","전달/중복","전달되는","전달된","전달될","전달됨","전달에","전달이","전달하고","전달하는","전달하는지","전달하도록","전달하든","전달하면","전달하지","전달한","전달한다고","전달한다면","전달할","전달합니다.","전달해","전달해도","전달해야","전달했기","전략","전략.","전략들은","전략에서","전략으로","전략은","전략을","전략이","전면에서","전부","전송되는","전에","전에,","전역","전역에서","전역으로","전역으로도","전역의","전역입니다.","전용","전용(read","전용(readonly)으로","전용(readonly)이라고","전용으로","전용이고","전용이기","전용이라면,","전용이었다면,","전자에","전적으로","전제로","전처리","전처리를","전체","전체는","전체에서","전통적으로","전통적으로,","전통적인","전혀","전형적으로","전환하기","전환하려는","전환할","절","절대","절대로","절대적인","절에","절에서","점","점만","점에","점에서","점으로","점은","점을","점이","점입니다.","점진적으로","점차적으로","점프합니다.","점프했다는","접근","접근법이라는","접근에","접근으로","접근을","접근이","접근자","접근자,","접근자가","접근자는","접근자를","접근자에","접근자의","접근하거나","접근하기","접근하기를","접근하는","접근하며,","접근하면","접근하면,","접근하지","접근할","접근해","접두사","접두사는","접두어로","접미사","접미사는","접미사를","정교한","정규식","정규식과","정규식을","정답은","정당한","정도","정도로","정도의","정렬","정렬하기","정렬합니다.","정리하도록","정말","정말로","정방향","정보","정보)에도","정보가","정보는","정보는,","정보도","정보로","정보를","정보만","정보에서","정보와","정의","정의가","정의는","정의되고","정의되고,","정의되면,","정의되어","정의되지","정의된","정의됩니다.","정의들이","정의로","정의를","정의만","정의에","정의의","정의하고","정의하고,","정의하기","정의하는","정의하는데","정의하는데엔","정의하면,","정의하지","정의한","정의할","정의합니다.","정의합니다:","정의해야","정의했다는","정적","정적인","정책이","정하게","정합니다.","정해","정해줄","정해지는","정해진","정확하게","정확한","정확할","정확함","정확합니다.","정확히","제거","제거되며,","제거되므로,","제거되어","제거된","제거됩니다.","제거하거나","제거하고","제거하기","제거하는","제거하면","제거한","제거할","제거합니다.","제거해보세요.","제공되는","제공되지","제공되지만","제공된","제공됩니다.","제공하고","제공하기","제공하는","제공하며,","제공하지","제공할","제공합니다","제공합니다\".","제공합니다.","제공합니다.일단","제공합니다:","제공합니다;","제공해야","제공해주지","제공해줍니다.","제공했는지를","제네레이터","제네릭","제네릭에서","제네릭을","제네릭의","제네릭이","제네릭이라","제네릭이므로","제네릭이지만,","제네릭입니다,","제대로","제안","제안된","제안의","제안이","제안이며","제약","제약사항을","제약조건","제약조건에서","제약조건을","제약조건이","제어하기","제어할","제외","제외)","제외.","제외되었는지에","제외된","제외될","제외됩니다.","제외됩니다.일반적으로","제외하고","제외하고).","제외하고;","제외하고는","제외하곤","제외하기","제외하면","제외한","제외합니다.","제외합니다.allowjs가","제외해야","제출하세요.","제한","제한되어","제한되지","제한된","제한됩니다:","제한을","제한적으로","제한점이","제한하고","제한하는","제한하지","제한할","제한합니다.","조건","조건과","조건부","조건부가","조건부의","조건에","조건에서만","조건은","조건을","조건이","조금","조용히","조작할","조절할","조정은","조치를","조합","조합:","조합으로","조합을","조합이","조회되어야","조회됩니다.","조회를","조회하고","조회합니다:","존재","존재.","존재를","존재하거나","존재하기는","존재하는","존재하는지","존재하는지와","존재하더라도","존재하더라도,","존재하므로,","존재하지","존재한다고","존재한다는","존재할","존재합니다.","존재합니다.javascript","존재합니다.이러한","존재해도","좀","좁혀지면","좁혀집니다.","좁히고","좁히고,","좁히는","좁힙니다:","종료한","종류","종류가","종류를","종류와","종류의","종종","좋게도,","좋습니다","좋습니다.","좋습니다.(아래의","좋습니다:","좋아요","좋았어!javascript에서","좋은","좋을","좋음","좌절의","주고","주고,","주로","주로,","주목하세요,","주목하세요.","주목하세요;","주목하십시오.이로","주목할만한","주목해","주변","주변에","주석","주석으로","주석은","주석을","주석의","주석입니다.","주세요.","주어야","주어지고","주어지는지에","주어지면","주어진","주요","주요한","주의사항","주의사항:","주의할","주의해","주의해서","주의해야","주입되는","주입합니다.","주제","주제로,","주제를","주제와","주지","준","준다.","준비가","준비됐나요?","줄","줄로","줄에","줄에서","줄에서,","줄여주는","줄여주었습니다.","줄은","줄을","줄의","줄이","줄이도록","줄이지","줄일","줍니다.","줍시다.","중","중,","중간","중괄호({","중단하지","중복해서","중에","중에는","중요하다는","중요하지","중요한","중요합니다","중요합니다.","중요합니다.:","중요합니다:","중인","중점을","중지하고","중지합니다.","중지했을","중첩","중첩된","중첩될","중첩하는","즉","즉,","즉시","즐겁다는","즐겨","증가된","증가하고","증가하는","증가한","증명할","증분","지","지금","지금까지","지금까지는","지금부터","지금은","지난","지루하지만","지시문이","지시어는","지시어로","지시어를","지시어와","지시어입니다.","지시자","지시자를","지시하고","지시합니다.","지시합니다.또한","지식을","지식이","지어","지역","지역적으로","지역화,","지연되는","지연될지,","지연됩니다,","지우고","지우지","지워집니다","지원","지원:","지원과","지원되는","지원되지","지원됩니다.","지원보다","지원은","지원을","지원이","지원하고","지원하기","지원하는","지원하며","지원하며,","지원하지","지원할","지원합니다.","지원합니다:","지원해야","지을","지점","지점부터","지점이","지정","지정:","지정되면","지정되어","지정되어야함.","지정되지","지정된","지정됩니다.","지정에","지정자","지정자나","지정자는","지정자도","지정자로","지정자를","지정자와","지정자입니다:","지정하고","지정하기","지정하는","지정하는데","지정하는데도","지정하려고","지정하려면","지정하면","지정하여","지정하지","지정하지만,","지정한","지정할","지정함으로써","지정합니다.","지정합니다:","지정해","지정해야","지정했다면)","지침","지침을","지향","지향적","직관만","직관적인","직관적입니다.","직관적입니다:","직렬로","직전에","직접","직접적으로","진단","진단할","진입점을","진짜","진행","진행되면,","진행되어","진행되지만","진행됩니다.","진행하면서","진행할","질문","질문은","질문을","질문처럼,","질문할","질문해","질의","집니다.","집어넣어","집중되어","집합","집합과","집합에","집합에서","집합을","집합이","집합이므로","집합이므로,","집합입니다","짓는","짓밟지","짚고","짜증을","짧게","짧아진","짧은","쪼갤","쪽도","쪽에서","쪽으로든)에","쪽의","찍으려면","찍지","차별","차용합니다.","차이가","차이를","차이점","차이점에","차이점은","차이점은,","차이점을","차이점이","참/거짓(true/false)","참고","참고)또는","참고:","참고로","참고로,","참고사항","참고하세요","참고하세요)","참고하세요.","참고하세요.)","참고하여","참고해","참여","참여하기","참여하는","참조","참조(원래","참조).","참조)를","참조가","참조는","참조되는","참조된","참조될","참조됩니다","참조를","참조에","참조에는","참조에서","참조이므로","참조하고","참조하기","참조하는","참조하는데","참조하는지","참조하세요.","참조하세요.)","참조하십시오.","참조할","참조합니다).","참조합니다.","참조해서","참조해야","찹조합니다.","창","창에서","창을","찾고","찾고,","찾고자","찾기","찾는","찾는데","찾도록","찾습니다.","찾아내는지를","찾아냈기","찾아야","찾았다는","찾았다면,","찾았습니다.","찾으려고","찾으세요.","찾으실","찾은","찾을","찾을지","찾음.","찾지","채우세요:","채워","채택되면","채택하게","챕터에","챕터에서","처럼","처럼)","처리","처리되고","처리되는지","처리되며,","처리된","처리됩니다(모듈에서도","처리됩니다)","처리됩니다.","처리를","처리하는","처리하므로","처리하지","처리한","처리할","처리합니다.","처음","철자가","철저하지","첨부할","첫","첫번째","첫째로","첫째로,","체계가","체계를","체이닝","체인에서","체인으로","체인을","체크","체크할","초","초과","초과한다면,","초기에는","초기의","초기화","초기화가","초기화되는","초기화되지","초기화된","초기화될","초기화됩니다.","초기화를","초기화하고","초기화하고,","초기화하는","초기화하더라도","초기화할","초기화합니다.","초기화해야","초기화했습니다.","초래서는","초심자에","초월한","초점을","최근","최근에","최대","최대한","최상위","최선을","최선의","최소","최소한","최신","최적","최적입니다.","최적화","최적화를","최적화할","최종","최종적으로","추가","추가되기","추가되는","추가되어야","추가되었습니다.","추가된","추가될","추가됩니다.","추가로","추가적으로","추가적으로,","추가적인","추가하거나","추가하게","추가하겠습니다:","추가하고","추가하고자","추가하기","추가하길","추가하는","추가하면","추가하면,","추가하세요.","추가하십시오","추가하십시오.","추가하십시오.그런","추가하여","추가하지","추가한","추가한다면,","추가할","추가합니다","추가합니다.","추가합니다.default가","추가합니다.npm과","추가합니다:","추가합니다;","추가해","추가해야","추가했습니다.","추가했어야","추론","추론되기도","추론되길","추론되는지","추론되지","추론된","추론된)","추론된다.","추론됩니다.","추론은","추론을","추론의","추론이","추론하는","추론하는지","추론하려면","추론하지","추론할","추론합니다.","추론합니다:","추론합니다만,","추론해볼","추상","추상으로","추상이","추상할","추상화","추상화할","추적","추적을","추적하고","추적할","추천하는","추천합니다.","추출","추출하여","추출할","추출합니다.","축약형일","축약형입니다.","출력","출력(concaten","출력과","출력된","출력됩니다.","출력물에서","출력물을","출력에","출력에는","출력에서","출력에서는","출력은","출력을","출력의","출력이","출력하도록","출력할","출력합니다.","출력했을","출발점이지만,","출처인","충돌","충돌에","충돌은","충돌을","충돌의","충돌이","충돌하고,","충돌하며,","충돌하지","충분한","충분합니다.","충분히","충족시키도록","충족하면,","취급됨)","취급됩니다:","취급하고","취급하지","취급할","취급합니다.","취소합니다.","취하고","취하려는","취하여","취하지","취할지","측면(생성자","측면.","측면과","측면에서","측면에서만","측면을","측면이","측에서","친숙하게","카드가","카드를","캄파일","캐스트","캐스트(cast)","캐스트를","캐시","캡처(capture)","캡처는","캡처된","캡처하고","캡처할","캡처함","캡처합니다:","캡쳐되면","캡쳐된","캡쳐링","캡쳐링에","캡쳐링을","캡쳐링의","캡쳐하기","캡쳐했기","커맨드","커뮤니티에서도","커버할","커서를","커스텀","커지면,","컨셉","컨셉들에서","컨테이너가","컨텍스트","컨텍스트(예:","컨텍스트가","컨텍스트를","컨텍스트에","컨텍스트에서","컨텐츠가","컨트롤을","컬렉션","컴파일","컴파일된","컴파일됩니다.","컴파일됩니다:","컴파일러","컴파일러/언어","컴파일러가","컴파일러는","컴파일러를","컴파일러만","컴파일러에","컴파일러에게","컴파일러에는","컴파일러의","컴파일러입니다.따라서","컴파일에","컴파일에서","컴파일은","컴파일을","컴파일의","컴파일이","컴파일하고,","컴파일하기","컴파일하는","컴파일하도록","컴파일하면,","컴파일하세요.이","컴파일하여","컴파일할","컴파일합니다.","컴파일합니다.이를","컴포넌트","컴포넌트(sfc)로","컴포넌트나","컴포넌트는","컴포넌트로","컴포넌트를","컴포넌트에","컴포넌트에서도","컴포넌트의","컴퓨터에","케이스","케이스가","케이스들이","케이스를","케이스에","코드","코드(code","코드,","코드:","코드가","코드나","코드는","코드는,","코드들","코드로","코드를","코드베이스에서","코드에","코드에서","코드에서,","코드에서는","코드와","코드와의","코드의","코드입니다.","코드처럼","코딩된","코어","콘솔에","콘텍스트에","콘텐츠에서","콜론은","콜백","콜백에","콜백에서","콜백은","콜백을","콜백의","콜백이","콤마","쿼리","쿼리와","쿼리처럼,","퀵","큐를","크게","크기가","큰","큰따옴표","클라이언트","클래스","클래스)에서","클래스,","클래스가","클래스나","클래스내에서","클래스는","클래스도","클래스들은","클래스들의","클래스들이","클래스라면","클래스로","클래스로부터","클래스를","클래스뿐만","클래스안의","클래스에","클래스에서","클래스에서만","클래스엔","클래스와","클래스와는","클래스와도","클래스의","클래스입니다.","클래스처럼,","클래스형","클래식","클래식.","클로저","클로저의","클릭","클릭하고","클릭하십시오.","클릭하십시오.'default'","클릭하십시오.그런","클릭합니다.그런","키","키고","키로","키를","키워드","키워드가","키워드는","키워드로","키워드를","키의","타게팅","타이프","타이핑","타이핑\"","타이핑(duck","타이핑(nomin","타이핑(subtyping)을","타이핑된","타이핑은","타이핑을","타이핑이기","타이핑이란","타임","타임/디자인","타임에","타임에만","타입","타입\"과","타입\"을","타입(subtype)이어야","타입(t가","타입(예:","타입(인덱스","타입)","타입)를","타입,","타입.","타입검사!","타입과","타입까지","타입니다.","타입도","타입들","타입들과","타입들로만","타입들로부터","타입들에서","타입들은","타입들을","타입들의","타입들이","타입만","타입만이","타입변수","타입변수를","타입보다","타입스크립트","타입에","타입에는","타입에도","타입에만","타입에서","타입에서,","타입으로","타입으로,","타입으로는:","타입으로도","타입으로만","타입으로써","타입으로의","타입은","타입은{","타입을","타입의","타입이","타입이거나","타입이고","타입이기","타입이나","타입이든","타입이라고","타입이라고도","타입이라는","타입이며","타입이므로,","타입이어야","타입인","타입인가?","타입인지","타입인지에","타입일","타입임","타입입니다","타입입니다,","타입입니다.","타입입니다:","타입처럼","타입화된","타케팅","타케팅하는","타협하지","탐색기를","탐색하면서","탐색할","탐지할","태그","태그(@async","태그는","태그들은","태그라고","태그로","태그를","태그에","태그와","태그의","태스크를","태스크에","탭을","테스트","테스트를","테스트입니다.","테스트입니다:","테스트하십시오.페이지에","테스트하여","테스트할","테이터","텍스트","텍스트를","템플릿","템플릿에서는","템플릿으로","템플릿을","템플릿이","템플릿입니다.","토큰을","통과","통과되고,","통과되지","통과의례입니다.","통과하길","통과하는지","통과했는지","통한","통합","통합됩니다.거기서","통합은","통합하기","통합할","통합합니다.","통합했습니다.","통해","통해)","통해,","통해서","통해서,","툴을","툴이","튜토리얼에서","튜토리얼에서는","튜토리얼이","튜플","튜플은","튜플을","튜플의","트랜스파일러를","트레이드","트리가","트리를","트리플","특별한","특별합니다.즉","특성","특성에","특성은","특성을","특수","특수한","특수화된","특정","특정한","특징","특징은","특화된","특히","특히,","틀과는","틀리거나","팀원들과","파라미터를","파라미터와","파생","파생되었기","파생된","파생될","파싱","파싱을","파악할","파이프","파일","파일(*.d.ts)의","파일(.js와","파일(declar","파일(lib.d.ts)은","파일,","파일/디렉터리","파일:","파일과","파일도","파일들:","파일들은","파일들은,","파일들을","파일로","파일만","파일별","파일별로","파일보다","파일뿐만","파일안에","파일에","파일에는","파일에서","파일에서,","파일에서는,","파일에선","파일은","파일을","파일의","파일이","파일이나","파일이라고","파일입니다.)","파일처럼","판결났다면","판단되는","판단을","판별","판별식","판별식.","패치","패치만","패키지","패키지가","패키지는","패키지도","패키지들은","패키지들을","패키지로","패키지를","패키지만","패키지에","패키지에는","패키지에서","패키지와","패키지의","패키징되기","패키징하기","패키징하지","패턴","패턴들","패턴들과","패턴들을","패턴들의","패턴에","패턴은","패턴을","패턴의","패턴이","패턴입니다.","패턴입니다:","팩토리","팩토리(jsx","팩토리가","팩토리는","팩토리를","팩토리에","팩토리입니다.","페이지","페이지,","페이지가","페이지도","페이지를","페이지에","페이지에서","페이지의","편리하게","편리하지만,","편리한","편리합니다.","편리합니다:","편의를","편이지만,","편집","편집기","편집기로","편집기에서","편하게","편한","평가","평가되는","평가되든지,","평가됩니다.","평가할","평범한","포괄할","포맷과","포맷에","포맷을","포맷이","포함","포함)","포함과","포함되고","포함되며","포함되면","포함되어","포함되어야","포함되지","포함된","포함될","포함됩니다","포함됩니다).","포함됩니다.","포함됩니다.\"exclude\"","포함됩니다.동봉된","포함시키기","포함시키지","포함시킬","포함시킵니다.","포함시킵니다.\"exclude\"","포함이","포함입니다.","포함하게","포함하고","포함하기","포함하는","포함하는지,","포함하도록","포함하여","포함하여,","포함하지","포함한","포함할","포함합니다.","포함합니다.\"outdir\"","포함합니다.node_modules/@types/*","포함합니다.typescript를","포함합니다:","포함해야","폴더","폴더가","폴더는","폴더로","폴더를","폴더에","폴더에서","폴더의","폴더입니다.","폴리필(polyfill)을","폴리필될","폴링","표기","표기'(","표기가","표기는","표기를","표기법으로","표기법을","표기에","표기와","표기하는","표기하여","표기해야","표시","표시가","표시되는","표시되며","표시되어야","표시되지","표시된","표시될","표시됩니다","표시됩니다.","표시됩니다.built에","표시됩니다;","표시로만","표시를","표시와","표시하기","표시하는","표시할","표시합니다.","표시해야","표준","표준과는","표준으로","표준의","표현","표현된","표현식","표현식과","표현식만","표현식에","표현식에서","표현식으로","표현식은","표현식을","표현식의","표현식이","표현식이나","표현식이라고","표현식입니다.","표현에서,","표현으로","표현은","표현을","표현의","표현이나","표현하기","표현하는","표현한","표현할","표현합니다.","표현해야","프레임워크","프레임워크를","프로그래머가","프로그래머들에겐","프로그래머들은","프로그래머의","프로그래밍","프로그래밍에서","프로그래밍의","프로그램","프로그램에서","프로그램을","프로그램의","프로그램이","프로세스를","프로세스에","프로세스입니다.","프로젝트","프로젝트가","프로젝트는","프로젝트를","프로젝트에","프로젝트에서","프로젝트의","프로젝트입니다.","프로토","프로토타입","프로토타입에","프로토타입을","프로토타입의","프로토타입입니다.","프로퍼티","프로퍼티,","프로퍼티가","프로퍼티는","프로퍼티는,","프로퍼티도","프로퍼티들(privat","프로퍼티들도","프로퍼티들에","프로퍼티들은","프로퍼티들을","프로퍼티들의","프로퍼티들이","프로퍼티로","프로퍼티로부터","프로퍼티를","프로퍼티만","프로퍼티만이","프로퍼티에","프로퍼티에만","프로퍼티에서,","프로퍼티와","프로퍼티의","프로퍼티이기","프로퍼티인","프로퍼티인지","프로퍼티입니다.","프로퍼티중","프로퍼티처럼","프록시","플래그","플래그가","플래그는","플래그로","플래그를","플래그와","플래그인","플랫폼)","플랫폼에서","플러그인","플러그인과","플러그인에","플러그인으로","플러그인은","플러그인을","플러그인이","플러그인입니다.","플러그인입니다.vinyl","플레이트를","피드백은","피연산자로","피하기","피하는","피할","피합니다.","필드","필드는","필드는,","필드로","필드를","필드에","필드에서는,","필드의","필수","필수,","필수로","필수적인","필요","필요가","필요는","필요로","필요시","필요에","필요하다고","필요하지","필요한","필요할","필요함)","필요합니다","필요합니다.","필요합니다.babel은","필요합니다.기본적으로","필요합니다.또한","필터링하는데","필터링할","하거나","하거나,","하게","하겠습니다.","하고","하고,","하고자","하기","하기는","하기와","하기위해","하나","하나)할","하나.","하나가","하나는","하나는,","하나라도","하나로","하나로써","하나를","하나만","하나씩","하나에","하나와","하나요","하나요?\"","하나의","하나이기","하나임을","하나입니다.","하는","하는데","하는지","하는지에","하단","하단의","하도록","하드","하려고","하려면","하려면,","하며","하며,","하면","하면,","하세요!","하세요.","하세요:","하십시오.","하에서","하위","하위클래스(subclasses),","하위클래스는","하위클래스를","하위클래스에","하위클래스에서","하위클래스에서만","하위클래스인","하위타입이","하위타입이지만","하이브리드","하지","하지는","하지만","하지만,","하향","한","한,","한곳으로","한글","한다고","한다는","한다면","한다면,","한번","한번에","한정되지만,","한정됩니다.","한쪽에만","한쪽에서","한쪽으로","할","할까요?","할당","할당.","할당과","할당되기","할당되는","할당되어","할당되었기","할당되었던","할당된","할당될","할당됩니다.","할당받을","할당에","할당에서","할당은","할당을","할당의","할당이","할당입니다:","할당하고","할당하는","할당하여","할당할","할당할지를","할당합니다","할당합니다.","할때","할지","할지라도,","할지입니다.","할필요가","함","함!","함)는","함)에서만","함께","함께)","함께)에서","함께,","함수","함수(anonym","함수(iif","함수(iife)","함수(name","함수)","함수)에","함수,","함수가","함수까지","함수나","함수는","함수는,","함수도","함수들이","함수라고","함수라는","함수라면,","함수로","함수로부터","함수로써,","함수를","함수만","함수만큼","함수안에서는","함수에","함수에게","함수에서","함수여야","함수와","함수의","함수이므로,","함수임을","함수입니다.","함수처럼","함수처럼,","함수형","함을","합니까?","합니다","합니다.","합니다.(3)을","합니다.npm","합니다.script","합니다.tsconfig는","합니다.webpack을","합니다.그것들은","합니다.그렇지","합니다.다행히도","합니다.유효한","합니다.이제","합니다.즉","합니다.출력","합니다.프로젝트를","합니다.향후에는","합니다:","합니다;","합니다만","합법적입니다.","합성","합성할","합을","합집합이라면","합쳐","합쳐진","합치는","합치도록","합치지","합칠","항목을","항목이","항상","항상for루프가","해","해결되며,","해결을","해결책은","해결책을","해결책입니다.","해결하기","해결할","해결합니다:","해당","해당,","해당되는","해당되지","해당하는","해당하므로","해당한다는","해당합니다.","해도","해봅시다.","해서,","해석","해석.","해석되거나,","해석되고","해석되기","해석되지","해석된","해석된다는","해석될","해석됩니다.","해석에","해석은","해석을","해석의","해석이","해석하기","해석하는","해석하려고","해석하여","해석하지","해석할","해석합니다.","해석합니다:","해시/우물","해야","해제할","해주는데,","해주며,","해주시면","해주어야","해주지만","해준다는","해줍니다.","해줍니다:","핵심","핸드북에서","핸드북은","핸드북을","핸드북의","했고","했기","했던","했듯이","했습니다!","했습니다.","했으므로","했을","행동을","행을","행일","향상된","향상이며,","향후","허용되는","허용되며","허용되며,","허용되므로,","허용되었기","허용되지","허용되지만,","허용된","허용됨","허용됩니다","허용됩니다!","허용됩니다.","허용됩니다:","허용하고","허용하는","허용하십시오.","허용하지","허용하지만,","허용할","허용합니다","허용합니다.","허용해주었습니다.","허용해준다는","허용했지만,","헤더","헬퍼","헬퍼를","현실적인","현재","현재,","현재로서는,","현재로선,","현재의","형성됩니다.","형성하고","형성하기","형식으로","형식을","형식의","형식인","형은","형태)","형태가","형태는","형태로","형태를","형태뿐입니다.","형태에","형태의","형태이고,","혜택","호스트","호스팅합니다.","호출","호출과","호출되는","호출되면","호출되어야","호출되었는지","호출되지","호출된","호출된다는","호출될","호출됩니다.","호출됩니다:","호출들은","호출들을","호출만","호출에","호출에서","호출은","호출을","호출의","호출이","호출하거나","호출하고","호출하기","호출하는","호출하도록","호출하려고","호출하면","호출하므로","호출하여","호출하여,","호출한","호출할","호출함","호출합니다.","호출해","호출해서","호출해야","호출했다는","호환","호환되기","호환되는","호환되는지","호환되며","호환되지","호환되지는","호환된다고","호환된다는","호환된다면","호환될","호환됩니다.","호환성","호환성에","호환성은","호환성을","호환성이","호환이","혹","혹시","혹은","혼동과","혼동하면","혼동하지","혼란스러움은","혼란스러워","혼란스러워지기","혼란스럽게도","혼란스럽고","혼란스럽습니다.","혼자만","혼합(mix)할","혼합(mix)합니다.","혼합됩니다.","혼합합니다.","화살","화살표","확대하는","확보할","확신한다면,","확신할","확실하게","확실한","확실할","확인","확인.","확인하거나","확인하고","확인하기","확인하기.","확인하는","확인하는데","확인하면","확인하세요.","확인하세요.msbuild","확인하세요:","확인하십시오","확인하십시오.","확인하여","확인할","확인함","확인합니다.","확인해야","확장","확장(extend)이","확장(extensions)으로","확장됩니다.","확장시켜야","확장에","확장을","확장이","확장자","확장자가","확장자로","확장자를","확장자만","확장하고","확장하기","확장하는","확장하면,","확장하여","확장한","확장한다는","확장할","확장해","확장해야","환경","환경과","환경에","환경에서","환경에서는","환경에서만","환경을","환경의","환영합니다:)","활성화되면","활성화되면,","활성화되어","활성화되어있는","활성화되어있지","활성화되었을","활성화하기","활성화하려면","활성화하면","활성화하여","활성화합니다.","활성화해야","활성화해야합니다:","활용하므로","활용하여","활용할","활용합니다.","효과를","효과적으로","효율적으로","후","후,","후반부로","후보","후보가","후에","후에는","후에도","후에도,","후위","훌륭한","훨씬","휴리스틱을","흐름에서는","흐름을","흔한","흔히","흘러나오는","흥미로운","흥미로울","흥미롭게도","힌트를","힘들게","힘들어지는","힘듭니다."],"pipeline":["stopWordFilter","stemmer"]},"store":{"./":{"url":"./","title":"소개","keywords":"","body":"TypeScript-Handbook 한글 문서\n\nTypeScript Handbook을 번역하는 프로젝트입니다.\n진행 상황\n번역 진행 상황은 이곳을 통해 확인할 수 있습니다.\n참여하기\n누구나 참여 가능하며 참여하는 방법은 번역가이드 및 규칙과 CONTRIBUTING.md를 참고해 주세요.\n잘못된 번역, 오타, 번역 요청은 이슈에 등록 해주시면 감사하겠습니다.\n그 밖에도 다양한 의견 및 피드백은 언제나 환영합니다:)\n"},"pages/tutorials/TypeScript in 5 minutes.html":{"url":"pages/tutorials/TypeScript in 5 minutes.html","title":"5분 안에 보는 TypeScript","keywords":"","body":"Typescript로 간단한 웹 애플리케이션을 만들어 보겠습니다.\nTypeScript 설치하기 (Installing TypeScript)\nTypeScript를 설치하는 방법에는 크게 두 가지가 있습니다:\n\nnpm을 이용한 설치 (Node.js 패키지 매니저)\nTypeScript의 Visual Studio 플러그인 설치\n\nVisual Studio 2017과 Visual Studio 2015 Update 3는 기본적으로 Typescript를 포함하고 있습니다.\n만약 TypeScript를 Visual Studio과 함께 설치하지 않았다면 이곳에서 다운로드할 수 있습니다.\nNPM 사용자의 경우:\n> npm install -g typescript\n\n첫 번째 TypeScript 파일 만들기 (Building your first TypeScript file)\n에디터에서, greeter.ts 파일에 다음의 JavaScript 코드를 입력하세요:\nfunction greeter(person) {\n    return \"Hello, \" + person;\n}\n\nlet user = \"Jane User\";\n\ndocument.body.textContent = greeter(user);\n\n코드 컴파일하기 (Compiling your code)\n.ts 확장자를 사용했지만, 이 코드는 아직 일반 JavaScript 코드입니다.\n기존의 JavaScript 앱에서 이 코드를 바로 복사하여 붙여 넣을 수 있습니다.\n커맨드 라인에서 TypeScript 컴파일러를 실행하세요:\ntsc greeter.ts\n\n결과는 동일한 JavaScript 코드를 포함하고 있는 greeter.js 파일이 될 것입니다.\nJavaScript 앱에서 TypeScript를 사용하여 시작했습니다!\n이제 TypeScript가 제공하는 몇 가지 새로운 기능을 이용할 수 있습니다.\n다음과 같이 : string 타입 표기를 'person' 함수의 인수에 추가하세요.\nfunction greeter(person: string) {\n    return \"Hello, \" + person;\n}\n\nlet user = \"Jane User\";\n\ndocument.body.textContent = greeter(user);\n\n타입 표기 (Type annotations)\nTypeScript의 타입 표기는 함수나 변수의 의도된 계약을 기록하는 간단한 방법입니다.\n아래의 경우, greeter 함수를 단일 문자열 매개변수와 함께 호출하려고 합니다.\n우리는 greeter 함수 호출 시 매개변수로 배열을 전달하도록 변경해 볼 수 있습니다:\nfunction greeter(person: string) {\n    return \"Hello, \" + person;\n}\n\nlet user = [0, 1, 2];\n\ndocument.body.textContent = greeter(user);\n\n다시 컴파일하면, 오류가 발생한 것을 볼 수 있습니다:\nerror TS2345: Argument of type 'number[]' is not assignable to parameter of type 'string'.\n\n마찬가지로, greeter 함수 호출에서 모든 인수를 제거해보세요.\nTypeScript는 당신이 예상치 못한 개수의 매개변수로 이 함수를 호출했다는 것을 알려줄 것입니다.\n두 경우 모두, TypeScript는 코드의 구조와 타입 표기에 기반해서 정적 분석을 제공합니다.\n오류가 존재하기는 하지만, greeter.js 파일은 생성되었습니다.\n코드에 오류가 존재하더라도 TypeScript를 사용할 수 있습니다. 그러나 TypeScript는 코드가 예상대로 작동하지 않을 것이라는 경고를 하게 됩니다.\n인터페이스 (Interfaces)\n예제를 더 발전시켜 보겠습니다. 여기서는 firstName 및 lastName 필드를 갖고 있는 객체를 나타내는 인터페이스를 사용합니다.\nTypeScript에서, 내부 구조가 호환되는 두 타입은 서로 호환 됩니다.\n그래서 명시적인 implements 절 없이, 인터페이스가 요구하는 형태를 사용하는 것만으로도 인터페이스를 구현할 수 있습니다.\ninterface Person {\n    firstName: string;\n    lastName: string;\n}\n\nfunction greeter(person: Person) {\n    return \"Hello, \" + person.firstName + \" \" + person.lastName;\n}\n\nlet user = { firstName: \"Jane\", lastName: \"User\" };\n\ndocument.body.textContent = greeter(user);\n\n클래스 (Classes)\n마지막으로, 클래스를 사용하여 예제를 확장해 보겠습니다.\nTypeScript는 클래스 기반 객체 지향 프로그래밍 지원과 같은 JavaScript의 새로운 기능을 지원합니다.\n생성자와 public 필드를 사용해 Student 클래스를 만들겠습니다.\n클래스와 인터페이스가 잘 작동하여, 프로그래머가 올바른 추상화 수준을 결정할 수 있게 해준다는 점을 주목하세요.\n또한, 생성자의 인수에 public을 사용하는 것은 그 인수의 이름으로 프로퍼티를 자동으로 생성하는 축약형입니다.\nclass Student {\n    fullName: string;\n    constructor(public firstName: string, public middleInitial: string, public lastName: string) {\n        this.fullName = firstName + \" \" + middleInitial + \" \" + lastName;\n    }\n}\n\ninterface Person {\n    firstName: string;\n    lastName: string;\n}\n\nfunction greeter(person: Person) {\n    return \"Hello, \" + person.firstName + \" \" + person.lastName;\n}\n\nlet user = new Student(\"Jane\", \"M.\", \"User\");\n\ndocument.body.textContent = greeter(user);\n\ntsc greeter.ts를 재실행하면 생성된 JavaScript 코드가 이전의 코드와 동일하다는 것을 알 수 있습니다.\nTypeScript의 클래스는 단지 JavaScript에서 자주 사용되는 프로토타입-기반 OO의 축약형일 뿐입니다.\nTypeScript 웹 앱 실행하기 (Running your TypeScript web app)\n이제 아래의 코드를 greeter.html에 작성하세요:\n\n\n    TypeScript Greeter\n    \n        \n    \n\n\n브라우저에서 greeter.html을 열어 간단한 첫 번째 TypeScript 웹 앱을 실행해보세요!\n옵션: Visual Studio에서 greeter.js를 열거나, TypeScript playground에 코드를 복사하세요.\n식별자 위에 마우스를 올려놓으면 해당 타입을 볼 수 있습니다.\n경우에 따라 타입이 자동으로 추론되기도 한다는 점을 유의하세요.\n마지막 행을 다시 입력하고, DOM 요소 타입에 기반한 완료 목록과 매개변수 도움말을 확인하세요.\ngreeter 함수 참조 위에 커서를 올려놓고, F12 키를 눌러 해당 정의로 이동할 수 있습니다.\n또한, 심벌을 마우스 오른쪽 버튼으로 클릭하고 리팩토링을 사용하여 이름을 바꿀 수 있습니다.\n제공된 타입 정보는 애플리케이션 규모에서 JavaScript로 작동하는 도구와 함께 작동합니다.\nTypeScript와 관련된 더 많은 예시를 보려면, 웹사이트의 Samples 섹션을 참고하세요.\n\n"},"pages/tutorials/ASP.NET Core.html":{"url":"pages/tutorials/ASP.NET Core.html","title":"ASP.NET Core","keywords":"","body":"설정\nASP.NET 코어 및 TypeScript 설치 (Install ASP.NET Core and TypeScript)\n먼저 필요한 경우에는 ASP.NET Core를 설치합니다.이 퀵 스타트 가이드를 위해서는 VisualStudio2015 또는 2017이 필요합니다.\n다음으로 사용 중인 VisualStudio에 최신 TypeScript가 아직 없는 경우 이를 설치할 수 있습니다.\n새 프로젝트 만들기 (Create a new project)\n\n파일 선택\n새로운 프로젝트 선택 (Ctrl + Shift + N)\nVisual C# 선택\nVS2015의 경우 ASP.NET Web Application > ASP.NET 5 Empty를 선택하고 로컬에서 실행하기 때문에 \"Host in the cloud\" 선택을 취소합니다.\n \n VS2017의 경우 ASP.NET Core Web Application (.NET Core) 대신 ASP.NET Core 1.1 Empty 를 선택하세요.\n \n\n\n애플리케이션을 실행하고 작동하는지 확인합니다.\n서버 설정 (Set up the server)\nVS2015\nproject.json에서 \"dependencies\"에 다음 항목을 추가합니다 :\n\"Microsoft.AspNet.StaticFiles\": \"1.0.0-rc1-final\"\n\n의존성은 다음과 같아야 합니다 :\n  \"dependencies\": {\n    \"Microsoft.AspNet.IISPlatformHandler\": \"1.0.0-rc1-final\",\n    \"Microsoft.AspNet.Server.Kestrel\": \"1.0.0-rc1-final\",\n    \"Microsoft.AspNet.StaticFiles\": \"1.0.0-rc1-final\"\n  },\n\nStartup.cs에서 Configure를 다음으로 교체합니다.\npublic void Configure(IApplicationBuilder app)\n{\n    app.UseIISPlatformHandler();\n    app.UseDefaultFiles();\n    app.UseStaticFiles();\n}\n\nVS2017\nOpen Dependencies > Manage NuGet Packages > Browse. 검색 및 설치  Microsoft.AspNetCore.StaticFiles 1.1.2:\n\nStartup.cs에서 Configure를 다음으로 교체합니다.\npublic void Configure(IApplicationBuilder app)\n{\n    app.UseDefaultFiles();\n    app.UseStaticFiles();\n}\n\nUseDefaultFiles와 UseStaticFiles 아래의 빨간선이 사라지려면 VS를 다시 시작해야 할 수 있습니다.\n타입스크립트 추가 (Add TypeScript)\n다음 단계는 TypeScript를 위한 폴더를 추가하는 것입니다.\n\n그냥 scripts라고 부르겠습니다.\n\n타입스크립트 코드 추가 (Add TypeScript code)\nscripts를 마우스 오른쪽 버튼으로 클릭하고 New Item을 클릭합니다.그런 다음 TypeScript File (.NET Core 섹션에 있을 수도 있음)을 선택하고 app.ts의 이름을 지정합니다.\n\n예제 코드 추가 (Add example code)\napp.ts에 다음 코드를 입력하십시오\nfunction sayHello() {\n    const compiler = (document.getElementById(\"compiler\") as HTMLInputElement).value;\n    const framework = (document.getElementById(\"framework\") as HTMLInputElement).value;\n    return `Hello from ${compiler} and ${framework}!`;\n}\n\n빌드 설정 (Set up the build)\nTypeScript 컴파일러 설정 (Configure the TypeScript compiler)\n먼저 TypeScript에 빌드 방법을 알려줘야 합니다.scripts 폴더를 마우스 오른쪽 버튼으로 클릭하고 New Item을 클릭합니다.그런 다음 TypeScript ConfigurationFile을 선택하고 기본 이름인 tsconfig.json을 사용하십시오.\n\n기본 tsconfig.json를 다음으로 대체하세요:\n{\n  \"compilerOptions\": {\n      \"noImplicitAny\": true,\n      \"noEmitOnError\": true,\n      \"sourceMap\": true,\n      \"target\": \"es5\"\n  },\n  \"files\": [\n      \"./app.ts\"\n  ],\n  \"compileOnSave\": true\n}\n\n다음과 같은 차이점을 제외하고 기본값과 유사합니다.\n\n\"noImplicitAny\": true 설정합니다.\n\"excludes\"에 의존하지 않고 명시적으로 \"files\" 리스트를 나열합니다.\n\"compileOnSave\": true 설정합니다.\n\n새로운 코드를 작성할 때마다 \"nomaplicitany\"가 좋습니다 - — 실수로 타입이 지정되지 않은 코드를 쓰지 않도록 할 수 있습니다.\"compileOnSave\"는 실행 중인 웹 앱에서 코드를 손쉽게 업데이트할 수 있도록 해 준다.\nNPM 설정 (Set up NPM)\n이제 JavaScript 패키지를 다운로드할 수 있도록 NPM을 설정해야 합니다.프로젝트를 마우스 오른쪽 버튼으로 누르고 New Item을 클릭하십시오.그런 다음 NPM Configuration File을 선택하고 기본 이름 package.json을 사용하십시오.  \ndevDependencies '안에 \"gulp\"와 \"del\"을 추가하십시오 :\n\"devDependencies\": {\n    \"gulp\": \"3.9.0\",\n    \"del\": \"2.2.0\"\n}\n\nVisual Studio는 파일을 저장하는 즉시 gulp 및 del 설치를 시작해야 합니다.그렇지 않은 경우 패키지를 마우스 오른쪽 버튼으로 누르고 Restore Packages를 하십시오.\ngulp 설정 (Set up gulp)\n마지막으로 gulpfile.js라는 새로운 JavaScript파일을 추가하십시오.\n다음 코드를 입력합니다.\n/// \n/*\n이 파일은 Gulp의 작업을 정의하고 플러그인을 사용하기 위한 entry point입니다.\n자세한 내용을 보려면 여기를 클릭하십시오. http://go.microsoft.com/fwlink/?LinkId=518007\n*/\n\nvar gulp = require('gulp');\nvar del = require('del');\n\nvar paths = {\n    scripts: ['scripts/**/*.js', 'scripts/**/*.ts', 'scripts/**/*.map'],\n};\n\ngulp.task('clean', function () {\n    return del(['wwwroot/scripts/**/*']);\n});\n\ngulp.task('default', function () {\n    gulp.src(paths.scripts).pipe(gulp.dest('wwwroot/scripts'))\n});\n\n첫 번째 줄은 Visual Studio에게 빌드가 끝난 후에 작업을 'default'로 실행하도록 지시합니다.또한 Visual Studio에 빌드를 정리하도록 요청하면 'clean'작업도 실행됩니다.\n이제 gulpfile.js를 마우스 오른쪽 버튼으로 클릭하고 Task Runner Explorer를 클릭하십시오.'default' 및 'clean'작업이 표시되지 않으면 탐색기를 새로고침 합니다 :\n\nHTML 페이지 작성 (Write an HTML page)\nwwwroot 안에 index.html이라는 새 항목을 추가합니다.\n다음 코드를 index.html에 사용합니다 :\n\n\n\n    \n    \n    \n\n\n    \n    \n        Compiler: \n        Framework: \n    \n\n\n\n테스트 (Test)\n\n프로젝트를 실행하십시오.\n입력 상자에 입력할 때 메시지가 표시됩니다 :\n\n\n디버그 (Debug)\n\nEdge에서 F12 키를 누르고 Debugger 탭을 클릭하십시오.\n첫 번째 localhost 폴더를 찾은 다음 scripts/app.ts를 찾습니다.\nreturn 라인이 있는 라인에 breakpoint를 설정합니다\nType 상자에 내용을 입력하고 breakpoint가 TypeScript 코드에 들어가고 검사가 올바르게 작동하는지 확인합니다.\n\n\nASP.NET 프로젝트에 기본적인 TypeScript를 포함시키기 위해 알아야 할 것은 이것뿐입니다.다음으로 간단한 Angular 앱을 작성합니다.\n앵귤러 2 추가 (Add Angular 2)\nNPM 의존성 추가 (Add NPM dependencies)\npackage.json의 dependencies에 Angular 2와 SystemJS를 추가하십시오.\nVS2015의 경우는 새로운 dependencies 리스트 :\n  \"dependencies\": {\n    \"angular2\": \"2.0.0-beta.11\",\n    \"systemjs\": \"0.19.24\",\n    \"gulp\": \"3.9.0\",\n    \"del\": \"2.2.0\"\n  },\n\nVS2017의 경우 NPM3에서 peer 의존성이 사용되지 않으므로 Angular 2의 peer 의존성을 의존성으로 직접 나열해야 합니다 :\n  \"dependencies\": {\n    \"angular2\": \"2.0.0-beta.11\",\n    \"reflect-metadata\": \"0.1.2\",\n    \"rxjs\": \"5.0.0-beta.2\",\n    \"zone.js\": \"^0.6.4\",\n    \"systemjs\": \"0.19.24\",\n    \"gulp\": \"3.9.0\",\n    \"del\": \"2.2.0\"\n  },\n\ntsconfig.json 업데이트 (Update tsconfig.json)\n이제 Angular 2와 그 의존성이 설치되었으므로 TypeScript의 데코레이터에 대한 실험적 지원이 필요합니다.또한 Promise과 같은 것들에는 Angular가 core-js를 사용하기 때문에 ES2015에 선언을 추가해야 합니다.향후에는 데코레이터가 기본이 될 것이므로 이러한 설정은 필요하지 않을 것입니다.\n\"experimentalDecorators\": true, \"emitDecoratorMetadata\": true를 \"compilerOptions\"에 추가하십시오.그런 다음 ES2015에서 선언을 가져오려면 \"lib\": [\"es2015\", \"es5\", \"dom\"]을 \"compilerOptions\" 에 추가하십시오.  \n마지막으로 만들 \"./model.ts\"를 \"files\"에 새 항목을 추가해야 합니다.tsconfig는 다음과 같이 보일 것입니다 :\n{\n    \"compilerOptions\": {\n        \"noImplicitAny\": true,\n        \"noEmitOnError\": true,\n        \"sourceMap\": true,\n        \"experimentalDecorators\": true,\n        \"emitDecoratorMetadata\": true,\n        \"target\": \"es5\",\n        \"lib\": [\n            \"es2015\", \"es5\", \"dom\"\n        ]\n    },\n    \"files\": [\n        \"./app.ts\",\n        \"./model.ts\",\n        \"./main.ts\"\n    ],\n    \"compileOnSave\": true\n}\n\ngulp 빌드에 Angular 추가 (Add Angular to the gulp build)\n마지막으로 Angular 파일을 빌드의 일부로 복사해야 합니다.\n추가할 사항은 다음과 같습니다:\n\n라이브러리 파일에 대한 경로.\nlib 태스크를 추가하여 파일을 wwwroot에 연결(pipe) 합니다.\ndefault 태스크에 lib에 대한 의존성을 추가하십시오.\n\n업데이트된 gulpfile.js은 다음과 같이 표시됩니다 :\n/// \n/*\n이 파일은 Gulp의 작업을 정의하고 플러그인을 사용하기 위한 entry point입니다.\n자세한 내용을 보려면 여기를 클릭하십시오. http://go.microsoft.com/fwlink/?LinkId=518007\n*/\n\nvar gulp = require('gulp');\nvar del = require('del');\n\nvar paths = {\n    scripts: ['scripts/**/*.js', 'scripts/**/*.ts', 'scripts/**/*.map'],\n    libs: ['node_modules/angular2/bundles/angular2.js',\n           'node_modules/angular2/bundles/angular2-polyfills.js',\n           'node_modules/systemjs/dist/system.src.js',\n           'node_modules/rxjs/bundles/Rx.js']\n};\n\ngulp.task('lib', function () {\n    gulp.src(paths.libs).pipe(gulp.dest('wwwroot/scripts/lib'));\n});\n\ngulp.task('clean', function () {\n    return del(['wwwroot/scripts/**/*']);\n});\n\ngulp.task('default', ['lib'], function () {\n    gulp.src(paths.scripts).pipe(gulp.dest('wwwroot/scripts'));\n});\n\n다시 한번 gulpfile을 저장한 후에는 Task Runner Explorer가 새로운 lib 작업을 보게해야 합니다.\nTypeScript에 간단한 Angular 애플리케이션 작성 (Write a simple Angular app in TypeScript)\n먼저 app.ts의 코드를 다음과 같이 변경하십시오 :\nimport {Component} from \"angular2/core\"\nimport {MyModel} from \"./model\"\n\n@Component({\n    selector: `my-app`,\n    template: `Hello from {{getCompiler()}}`\n})\nexport class MyApp {\n    model = new MyModel();\n    getCompiler() {\n        return this.model.compiler;\n    }\n}\n\n그런 다음 Model.ts라는 이름의 scripts에 다른 TypeScript 파일을 추가하십시오 :\nexport class MyModel {\n    compiler = \"TypeScript\";\n}\n\n그리고 scripts에 main.ts라는 또 다른 TypeScript 파일이 있습니다 :\nimport {bootstrap} from \"angular2/platform/browser\";\nimport {MyApp} from \"./app\";\nbootstrap(MyApp);\n\n마지막으로 index.html의 코드를 다음과 같이 변경하십시오 :\n\n\n\n    \n    \n    \n    \n    \n    \n    System.config({\n        packages: {\n            'scripts': {\n                format: 'cjs',\n                defaultExtension: 'js'\n            }\n        }\n    });\n    System.import('scripts/main').then(null, console.error.bind(console));\n    \n    \n\n\n    Loading...\n\n\n\n그러면 앱이 로드됩니다.ASP.NET 애플리케이션을 실행하면 \"loading...\" 이라고 표시된 다음 \"Hello from TypeScript\" div가 표시됩니다.\n"},"pages/tutorials/Gulp.html":{"url":"pages/tutorials/Gulp.html","title":"걸프","keywords":"","body":"이 퀵 스타트 가이드는 gulp로 TypeScript를 빌드한 다음 Browserify, uglify 또는 Watchify를 gulp 파이프 라인에 추가하는 방법을 알려줍니다.\n또한 Babelify를 사용하여 Babel 기능에 대한 기능을 추가합니다.npm과 함께 Node.js는 이미 사용하고 있다고 가정합니다.\n작은 프로젝트 (Minimal project)\n새로운 디렉토리부터 시작합시다.\n당장은 proj라고 이름을 붙이겠지만 원하는 대로 변경할 수 있습니다.\nmkdir proj\ncd proj\n\n시작하려면 다음과 같은 방식으로 프로젝트를 구조화해야 합니다:\nproj/\n   ├─ src/\n   └─ dist/\n\nTypeScript 파일은 src 폴더에서 시작하여 TypeScript 컴파일러를 통해 실행되고 dist에서 끝납니다.\n이것을 골격으로 합니다:\nmkdir src\nmkdir dist\n\n프로젝트 초기화 (Initialize the project)\n이제 이 폴더를 npm 패키지로 바꿀 것입니다.\nnpm init\n\n일련의 알림을 받게 될 것입니다.entry point를 제외하고는 기본값을 사용할 수 있으며 ./dist/main.js를 사용합니다.package.json 파일로 돌아가서 언제든 변경할 수 있습니다.\n의존성 설치 (Install our dependencies)\n이제는 npm install을 사용하여 패키지를 설치할 수 있습니다.먼저 gulp-cli를 글로벌 설치하십시오 (Unix 시스템을 사용하는 경우 npm install 명령 앞에 sudo를 붙여야 할 수도 있습니다).\nnpm install -g gulp-cli\n\n그런 다음 프로젝트의 개발자 의존성에 typescript, gulp 및 gulp-typescript를 설치하십시오.Gulp-typescript는 Typescript의 gulp 플러그인입니다.\nnpm install --save-dev typescript gulp gulp-typescript\n\n간단한 예제 작성 (Write a simple example)\nHello World 프로그램을 작성해 보겠습니다.\nsrc에 main.ts 파일을 만듭니다 :\nfunction hello(compiler: string) {\n    console.log(`Hello from ${compiler}`);\n}\nhello(\"TypeScript\");\n\nproj이라는 프로젝트 루트에 tsconfig.json 파일을 생성합니다 :\n{\n    \"files\": [\n        \"src/main.ts\"\n    ],\n    \"compilerOptions\": {\n        \"noImplicitAny\": true,\n        \"target\": \"es5\"\n    }\n}\n\ngulpfile.js 생성 (Create a gulpfile.js)\n프로젝트 루트에 gulpfile.js 파일을 만듭니다 :\nvar gulp = require(\"gulp\");\nvar ts = require(\"gulp-typescript\");\nvar tsProject = ts.createProject(\"tsconfig.json\");\n\ngulp.task(\"default\", function () {\n    return tsProject.src()\n        .pipe(tsProject())\n        .js.pipe(gulp.dest(\"dist\"));\n});\n\nresulting 앱 테스트 (Test the resulting app)\ngulp\nnode dist/main.js\n\n프로그램에서 \"Hello from TypeScript!\"를 인쇄해야합니다.\n코드에 모듈 추가 (Add modules to the code)\nBrowserify를 시작하기 전에 코드를 만들고 믹스에 모듈을 추가해 보겠습니다.이것은 실제 앱에서 사용하기 쉬운 구조입니다.\nsrc/greet.ts 파일을 만듭니다 :\nexport function sayHello(name: string) {\n    return `Hello from ${name}`;\n}\n\n이제 src/main.ts의 sayHello를 greet.ts에서 가져오도록 변경합니다 :\nimport { sayHello } from \"./greet\";\n\nconsole.log(sayHello(\"TypeScript\"));\n\n마지막으로 src/greet.ts를 tsconfig.json에 추가하십시오 :\n{\n    \"files\": [\n        \"src/main.ts\",\n        \"src/greet.ts\"\n    ],\n    \"compilerOptions\": {\n        \"noImplicitAny\": true,\n        \"target\": \"es5\"\n    }\n}\n\ngulp을 실행하고 노드에서 테스트하여 모듈이 작동하는지 확인하십시오 :\ngulp\nnode dist/main.js\n\nES2015 모듈 구문을 사용했지만 TypeScript는 Node가 사용하는 CommonJS 모듈을 방출했습니다.이 튜토리얼에서는 CommonJS를 계속 사용하겠지만 options 객체에 module을 설정하여 이를 변경할 수 있습니다.  \nBrowserify\n이제 이 프로젝트를 노드에서 브라우저로 이동하겠습니다.이를 위해 모든 모듈을 하나의 JavaScript 파일로 번들링 하고자 합니다.다행히도 정확히 Browserify가 하는 일입니다.더 좋은 것은 노드에서 사용하는 CommonJS 모듈 시스템을 TypeScript에서 사용할 수 있다는 것입니다.즉 TypeScript와 Node 설정이 기본적으로 변경되지 않은 브라우저로 전송되는 것을 의미합니다.\n먼저 browserify, tsify 및 vinyl-source-stream을 설치하십시오.tsify는 gulp-typescript처럼 Typeify 컴파일러에 접근할 수 있는 Browserify 플러그인입니다.vinyl-source-stream을 사용하면 Browserify의 파일 출력을 gulp에서 vinyl으로 인식하는 형식으로 다시 변환할 수 있습니다.\nnpm install --save-dev browserify tsify vinyl-source-stream\n\n페이지 만들기 (Create a page)\nsrc에 index.html 파일을 생성합니다 :\n\n\n    \n        \n        Hello World!\n    \n    \n        Loading ...\n        \n    \n\n\n이제 main.ts를 변경하여 페이지를 업데이트하십시오 :\nimport { sayHello } from \"./greet\";\n\nfunction showHello(divName: string, name: string) {\n    const elt = document.getElementById(divName);\n    elt.innerText = sayHello(name);\n}\n\nshowHello(\"greeting\", \"TypeScript\");\n\nshowHello 호출은 sayHello를 호출하여 paragraph 텍스트를 변경합니다.이제 gulpfile을 다음과 같이 변경하십시오 :\nvar gulp = require(\"gulp\");\nvar browserify = require(\"browserify\");\nvar source = require('vinyl-source-stream');\nvar tsify = require(\"tsify\");\nvar paths = {\n    pages: ['src/*.html']\n};\n\ngulp.task(\"copy-html\", function () {\n    return gulp.src(paths.pages)\n        .pipe(gulp.dest(\"dist\"));\n});\n\ngulp.task(\"default\", [\"copy-html\"], function () {\n    return browserify({\n        basedir: '.',\n        debug: true,\n        entries: ['src/main.ts'],\n        cache: {},\n        packageCache: {}\n    })\n    .plugin(tsify)\n    .bundle()\n    .pipe(source('bundle.js'))\n    .pipe(gulp.dest(\"dist\"));\n});\n\ncopy-html 태스크를 추가하고 default의 의존성으로 추가합니다.default가 실행될 때마다 copy-html이 먼저 실행되어야 한다는 것을 의미합니다.또한 default를 gulp-typescript 대신 tsify 플러그인으로 Browserify를 호출하도록 변경했습니다.편리하게도 둘 모두 TypeScript 컴파일러에 동일한 options 객체를 전달할 수 있습니다.\nbundle을 호출한 후 source(vinil-source-stream에 대한 별칭)를 사용하여 출력 번들 bundle.js의 이름을 지정합니다.\ngulp를 실행하고 브라우저에서 dist/index.html을 열어 페이지를 테스트하십시오.페이지에 \"Hello from TypeScript\"가 표시되어야 합니다.\nBrowserify에 debug : true를 지정한 것에 주목하십시오.이로 인해 tsify는 번들 JavaScript 파일 내에서 소스맵을 내보냅니다.소스 맵을 사용하면 번들로 제공된 JavaScript 대신 브라우저에서 원본 TypeScript 코드를 디버깅할 수 있습니다.브라우저의 디버거를 열고 main.ts 안에 브레이크포인트을 넣으면 소스 맵이 작동하는지 테스트할 수 있습니다.페이지를 새로 고침 할 때 브레이크포인트가 페이지를 일시 중지하고 greet.ts를 디버깅 할 수 있도록 해야 합니다.\nWatchify, Babel, and Uglify\n이제 코드를 Browserify에 묶어서 tsify 했으므로 browserify 플러그인을 사용하여 빌드에 다양한 기능을 추가할 수 있습니다.\n\nWatchify가 gulp를 계속 실행하며 파일을 저장할 때마다 점차적으로 컴파일합니다.이를 통해 브라우저에서 편집-저장-새로고침 사이클을 계속 진행할 수 있습니다.\n\nBabel은 ES2015 이상을 ES5 및 ES3으로 변환하는 매우 유연한 컴파일러입니다.따라서 TypeScript에서 지원하지 않는 광범위한 맞춤형 변환을 추가할 수 있습니다.\n\nUglify는 다운로드 시간을 줄이도록 코드를 압축합니다.\n\n\nWatchify\nWatchify로 백그라운드 컴파일을 시작하겠습니다 :\nnpm install --save-dev watchify gulp-util\n\n이제 gulpfile을 다음과 같이 변경하십시오 :\nvar gulp = require(\"gulp\");\nvar browserify = require(\"browserify\");\nvar source = require('vinyl-source-stream');\nvar watchify = require(\"watchify\");\nvar tsify = require(\"tsify\");\nvar gutil = require(\"gulp-util\");\nvar paths = {\n    pages: ['src/*.html']\n};\n\nvar watchedBrowserify = watchify(browserify({\n    basedir: '.',\n    debug: true,\n    entries: ['src/main.ts'],\n    cache: {},\n    packageCache: {}\n}).plugin(tsify));\n\ngulp.task(\"copy-html\", function () {\n    return gulp.src(paths.pages)\n        .pipe(gulp.dest(\"dist\"));\n});\n\nfunction bundle() {\n    return watchedBrowserify\n        .bundle()\n        .pipe(source('bundle.js'))\n        .pipe(gulp.dest(\"dist\"));\n}\n\ngulp.task(\"default\", [\"copy-html\"], bundle);\nwatchedBrowserify.on(\"update\", bundle);\nwatchedBrowserify.on(\"log\", gutil.log);\n\n여기에는 기본적으로 세 가지 변경 사항이 있지만 코드를 약간 리팩토링해야합니다.\n\nwatchify에 대한 호출에서 browserify 인스턴스를 감싸고 그 결과를 유지했습니다.\nwatchedBrowserify.on(\"update\", bundle);을 호출하여 Browserify 가 TypeScript 파일 중 하나가 변경될 때마다 bundle 함수를 실행하도록 했습니다.\nwatchedBrowserify.on(\"log\", gutil.log);을 호출하여 콘솔에 로그했습니다.\n\n(1)과 (2)는 default 작업에서 browserify를 호출해야 한다는 것을 의미합니다.Watchify와 Gulp 모두 호출해야 하기 때문에 default 함수에 이름을 주어야 합니다.(3)을 사용한 로깅을 추가하는 것은 선택 사항이지만 설정을 디버깅하는 데 매우 유용합니다.\n이제 Gulp를 실행하면 시작해야 하고 계속 실행됩니다.main.ts에서 showHello에 대한 코드를 변경하고 저장하십시오.  \n다음과 같은 출력이 표시되어야 합니다 :\nproj$ gulp\n[10:34:20] Using gulpfile ~/src/proj/gulpfile.js\n[10:34:20] Starting 'copy-html'...\n[10:34:20] Finished 'copy-html' after 26 ms\n[10:34:20] Starting 'default'...\n[10:34:21] 2824 bytes written (0.13 seconds)\n[10:34:21] Finished 'default' after 1.36 s\n[10:35:22] 2261 bytes written (0.02 seconds)\n[10:35:24] 2808 bytes written (0.05 seconds)\n\nUglify\n먼저 Uglify를 설치하십시오.Uglify의 요점은 코드를 압축하기 위한 것이므로 소스 맵을 유지하려면 vinyl-buffer와 gulp-sourcemaps도 설치해야 합니다.\nnpm install --save-dev gulp-uglify vinyl-buffer gulp-sourcemaps\n\n이제 gulpfile을 다음과 같이 변경하십시오 :\nvar gulp = require(\"gulp\");\nvar browserify = require(\"browserify\");\nvar source = require('vinyl-source-stream');\nvar tsify = require(\"tsify\");\nvar uglify = require('gulp-uglify');\nvar sourcemaps = require('gulp-sourcemaps');\nvar buffer = require('vinyl-buffer');\nvar paths = {\n    pages: ['src/*.html']\n};\n\ngulp.task(\"copy-html\", function () {\n    return gulp.src(paths.pages)\n        .pipe(gulp.dest(\"dist\"));\n});\n\ngulp.task(\"default\", [\"copy-html\"], function () {\n    return browserify({\n        basedir: '.',\n        debug: true,\n        entries: ['src/main.ts'],\n        cache: {},\n        packageCache: {}\n    })\n    .plugin(tsify)\n    .bundle()\n    .pipe(source('bundle.js'))\n    .pipe(buffer())\n    .pipe(sourcemaps.init({loadMaps: true}))\n    .pipe(uglify())\n    .pipe(sourcemaps.write('./'))\n    .pipe(gulp.dest(\"dist\"));\n});\n\nuglify 자체에는 하나의 호출만 있습니다 — buffer와 sourcemaps에 대한 호출은 sourcemaps이 계속 작동하는지 확인하기 위해 존재합니다.이러한 호출을 통해 이전과 같이 인라인 소스 맵을 사용하는 대신 별도의 소스 맵 파일을 사용할 수 있습니다.이제 Gulp를 실행하고 bundle.js가 난독화로 압축되는지 확인하십시오 :\ngulp\ncat dist/bundle.js\n\nBabel\n먼저 ES2015 전용 Babelify 및 Babel preset을 설치하십시오.Uglify처럼 Babelify도 코드를 엉망으로 만들기 때문에 vinyl-buffer와 gulp-sourcemaps이 필요합니다.기본적으로 Babelify는 확장자가 .js, .es, .es6 및 .jsx 인 파일만 처리하므로 Babelify에 옵션으로 .ts 확장자를 추가해야 합니다.\nnpm install --save-dev babelify babel-core babel-preset-es2015 vinyl-buffer gulp-sourcemaps\n\n이제 gulpfile을 다음과 같이 변경하십시오 :\nvar gulp = require('gulp');\nvar browserify = require('browserify');\nvar source = require('vinyl-source-stream');\nvar tsify = require('tsify');\nvar sourcemaps = require('gulp-sourcemaps');\nvar buffer = require('vinyl-buffer');\nvar paths = {\n    pages: ['src/*.html']\n};\n\ngulp.task('copyHtml', function () {\n    return gulp.src(paths.pages)\n        .pipe(gulp.dest('dist'));\n});\n\ngulp.task('default', ['copyHtml'], function () {\n    return browserify({\n        basedir: '.',\n        debug: true,\n        entries: ['src/main.ts'],\n        cache: {},\n        packageCache: {}\n    })\n    .plugin(tsify)\n    .transform('babelify', {\n        presets: ['es2015'],\n        extensions: ['.ts']\n    })\n    .bundle()\n    .pipe(source('bundle.js'))\n    .pipe(buffer())\n    .pipe(sourcemaps.init({loadMaps: true}))\n    .pipe(sourcemaps.write('./'))\n    .pipe(gulp.dest('dist'));\n});\n\nTypeScript 대상 ES2015도 필요합니다.Babel은 TypeScript에서 내보내는 ES2015 코드에서 ES5를 생성합니다.\ntsconfig.json을 수정합시다 :\n{\n    \"files\": [\n        \"src/main.ts\"\n    ],\n    \"compilerOptions\": {\n        \"noImplicitAny\": true,\n        \"target\": \"es2015\"\n    }\n}\n\nBabel의 ES5 출력은 간단한 스크립트에 대한 TypeScript의 출력과 매우 유사해야 합니다.\n"},"pages/tutorials/Migrating from JavaScript.html":{"url":"pages/tutorials/Migrating from JavaScript.html","title":"JavaScript에서 마이그레이션","keywords":"","body":"TypeScript는 공백 상태로 존재하지 않습니다.JavaScript 생태계를 염두에 두고 만들어졌으며 오늘날에는 많은 JavaScript가 존재합니다.JavaScript 코드 베이스를 TypeScript로 변환하는 것은 다소 지루하지만 보통 어렵지 않습니다.이 튜토리얼에서는 시작하는 방법을 살펴보겠습니다.새로운 TypeScript 코드를 작성하기에 충분한 핸드북을 읽은 것으로 가정합니다.\nReact 프로젝트를 변환하려는 경우 React Conversion Guide를 먼저 참조하는 것이 좋습니다.\n디렉토리 설정하기 (Setting up your Directories)\n평범한 JavaScript로 작성하는 경우 JavaScript가 src와 lib 또는 dist 디렉토리에 있는 .js 파일을 직접 실행하고 원하는 대로 실행할 수 있습니다.\n이런 경우 작성한 파일은 TypeScript의 입력으로 사용되며 생성된 출력을 실행하게 됩니다.JS에서 TS로 마이그레이션 하는 동안 TypeScript가 입력 파일을 덮어쓰지 않도록 입력 파일을 분리해야 합니다.출력 파일이 특정 디렉토리에 있어야 하는 경우 해당 파일이 출력 디렉토리가 됩니다.\n번들링이나 Babel과 같은 다른 트랜스파일러를 사용하는 것과 같이 JavaScript에서 중간 단계를 수행할 수도 있습니다.이런 경우에는 이와 같은 폴더 구조가 이미 설정되어 있을 수 있습니다.\n지금부터 디렉토리가 다음과 같이 설정되었다고 가정할 것입니다:\nprojectRoot\n├── src\n│   ├── file1.js\n│   └── file2.js\n├── built\n└── tsconfig.json\n\nsrc 디렉토리 밖에 tests 폴더가 있다면 src에 tsconfig.json와 tests에 하나씩 가질 수 있습니다.\n설정 파일 작성하기 (Writing a Configuration File)\nTypeScript는 tsconfig.json이라는 파일을 사용하여 포함시킬 파일과 검사의 종류와 같은 프로젝트의 옵션을 관리합니다.프로젝트에 사용할 기본적인 뼈대를 생성하겠습니다:\n{\n    \"compilerOptions\": {\n        \"outDir\": \"./built\",\n        \"allowJs\": true,\n        \"target\": \"es5\"\n    },\n    \"include\": [\n        \"./src/**/*\"\n    ]\n}\n\n여기서 TypeScript에 몇 가지를 지정합니다:\n\nsrc 디렉토리에의 모든 파일을 읽습니다 (include 포함)\nJavaScript 파일의 입력으로 허용합니다 (allowJs 포함)\nbuiltd에 모든 출력 파일을 내 보냅니다 (outDir와 함께)\n최신 JavaScript 구문을 ECMAScript 5 같은 이전 버전으로 변환합니다 (target 사용)\n\n이때 프로젝트 루트에 tsc를 실행하려고 하면 built 디렉토리에 출력 파일이 표시됩니다.built에 있는 파일의 레이아웃은 src의 레이아웃과 동일해야 합니다.이제 프로젝트에서 TypeScript로 작업해야 합니다.\n초기의 혜택 (Early Benefits)\n이 시점에서도 TypeScript에서 프로젝트를 이해함으로써 몇 가지 뛰어난 이점을 누릴 수 있습니다.VS Code나 Visual Studio 같은 편집기로 시작하면 자동 완성과 같은 도구 지원을 자주 받을 수 있습니다.또한 다음과 같은 옵션을 사용하여 특정 버그를 발견할 수도 있습니다:\n\nnoImplicitReturns는 함수의 끝에 반환문을 빼먹는 것을 방지합니다.\nnoFallthroughCasesInSwitch는 switch블록 case 사이에 break문을 뻬먹지 않기 위해 유용합니다.\n\nTypeScript는 도달 할 수없는 코드와 라벨에 대해서도 경고합니다.이 코드와 라벨은 각각의 allowUnreachableCode와 allowUnusedLabels로 해제할 수 있습니다.\n빌드 도구와 통합 (Integrating with Build Tools)\n파이프 라인에 빌드 단계가 더 있을 수 있습니다.아마도 각 파일에 무언가를 연결했을 것입니다.각 빌드 도구는 다르지만 각 빌드 도구의 요점을 다루기 위해 최선을 다할 것입니다.\nGulp\nGulp를 사용하는 경우 TypeScript로 Gulp 사용하기 튜토리얼이 있고 Browserify와 Babelify 그리고 Uglify와 같은 일반적인 빌드 도구와 통합됩니다.거기서 더 읽을 수 있습니다.\nWebpack\nWebpack 통합은 매우 간단합니다.\nTypeScript 로더인 awesome-typescript-loader를 source-map-loader와 결합하여 사용하면 디버깅이 쉬워 집니다.  \n간단한 실행\nnpm install awesome-typescript-loader source-map-loader\n\n그리고 다음의 옵션을 webpack.config.js 파일에 병합하십시오 :\nmodule.exports = {\n    entry: \"./src/index.ts\",\n    output: {\n        filename: \"./dist/bundle.js\",\n    },\n\n    // webpack의 출력을 디버깅 할 소스 맵을 사용하도록 설정합니다.\n    devtool: \"source-map\",\n\n    resolve: {\n        // 확인 가능한 확장자로 '.ts' 및 '.tsx'를 추가합니다.\n        extensions: [\"\", \".webpack.js\", \".web.js\", \".ts\", \".tsx\", \".js\"]\n    },\n\n    module: {\n        loaders: [\n            // '.ts' 또는 '.tsx' 확장자를 가진 모든 파일은 'awesome-typescript-loader'에 의해 처리됩니다.\n            { test: /\\.tsx?$/, loader: \"awesome-typescript-loader\" }\n        ],\n\n        preLoaders: [\n            // '.js' 파일의 모든 출력에는 'source-maps-loader'로 다시 처리된 소스 맵이 있습니다.\n            { test: /\\.js$/, loader: \"source-map-loader\" }\n        ]\n    },\n\n    // 다른 옵션들...\n};\n\n.js 파일을 다루는 다른 로더보다 awesome-typescript-loader를 먼저 실행해야 한다는 점에 주의해야 합니다.Webpack을 위한 TypeScript 로더인 ts-loader도 마찬가지입니다.여기에서. 그 둘의 차이점에 대해 더 읽어볼 수 있다.\nReact and Webpack에 관한 튜토리얼에서 Webpack을 사용하는 예를 볼 수 있습니다.\nTypeScript 파일로 이동 (Moving to TypeScript Files)\n이때 TypeScript 파일을 사용할 준비가 된 것입니다.첫 번째 단계는 .js 파일 중 하나의 이름을 .ts로 바꾸는 것입니다.파일이 JSX를 사용한다면 이름을 .tsx로 바꿔야 합니다.\n그 단계를 끝냈나요?\n좋았어!JavaScript에서 TypeScript로 파일을 성공적으로 마이그레이션 했습니다!\n물론 옳다고 생각하지 않을 수도 있습니다.TypeScript를 지원하는 편집기에서 해당 파일을 열면 (또는 tsc --pretty를 실행하면) 특정 라인에 빨간 줄이 나타날 수 있습니다.Microsoft Word와 같은 편집기에서 빨간 줄을 생각하는 것과 같은 방식으로 생각해야합니다.Word에서 여전히 문서를 인쇄할 수 있는 것처럼 TypeScript는 코드를 변환합니다.\n그 경고가 너무 느슨하면 그 경고를 엄격하게 할 수 있습니다.예를 들어 오류 발생으로 인해 TypeScript에서 JavaScript로 컴파일하는 것을 원치 않는 경우 noEmitOnError 옵션을 사용할 수 있습니다.그런 의미에서 TypeScript는 엄격함을 조절할 수 있는 도구를 가지고 있으며 원하는 만큼 조절할 수 있습니다.\n만약 사용 가능한 더 엄격한 설정을 사용할 계획이라면 지금 바로 설정하는 것이 가장 좋습니다.(아래의 Getting Stricter Checks 참조).\n예를 들어 TypeScript가 타입에 대해 any를 추론하지 않도록 명시하려면 파일을 수정하기 전에 noImplicitAny를 사용할 수 있습니다.다소 벅차다고 느껴질 수도 있지만 장기적 이득은 훨씬 더 빨리 나타납니다.\n오류 잡기 (Weeding out Errors)\n앞서 언급 한 것처럼 변환 후에 오류 메시지가 표시되는 것은 예상치 못한 일이 아닙니다.중요한 것은 이런 것들을 하나씩 살펴보고 어떻게 오류를 처리할 것인지를 결정하는 것입니다.종종 이것들은 문제없는 버그가 될 수도 있지만 때로는 TypeScript를 위해 조금 더 나은 것을 설명해야 할 것입니다.\n모듈 가져오기 (Importing from Modules)\nCannot find name 'require'.와 Cannot find name 'define'. 같은 오류가 발생하기 시작할 수 있습니다.이러한 경우 모듈을 사용하고 있을 가능성이 높습니다.\nTypeScript로 작성하는 동안 확실할 수 있지만\n// Node/CommonJS를 위한\ndeclare function require(path: string): any;\n\n또는\n// RequireJS/AMD를 위한\ndeclare function define(...args: any[]): any;\n\n이러한 호출들은 제거하고 import에 TypeScript 구문을 사용하는 것이 좋습니다.\n먼저 TypeScript의 module 플래그를 설정하여 일부 모듈 시스템을 활성화해야 합니다.유효한 옵션은commonjs,amd,system 그리고 umd입니다.\n다음 Node/CommonJS 코드를 가지고 있는 경우:\nvar foo = require(\"foo\");\n\nfoo.doStuff();\n\n또는 다음 RequireJS / AMD 코드:\ndefine([\"foo\"], function(foo) {\n    foo.doStuff();\n})\n\n그러면 다음과 같은 TypeScript 코드를 작성하게 됩니다:\nimport foo = require(\"foo\");\n\nfoo.doStuff();\n\n선언 파일 가져 오기 (Getting Declaration Files)\nTypeScript로 전환하기 시작하면 Cannot find module 'foo'.과 같은 오류가 발생할 수 있습니다.여기서 문제는 라이브러리를 설명할 수 있는 선언 파일(declaration files) 을 가지고 있지 않다는 것입니다.다행히도 이것은 꽤 쉽습니다.TypeScript에서 lodash와 같은 패키지에 대해 불평하는 경우 그냥 작성할 수 있습니다.\nnpm install -S @types/lodash\n\ncommonjs가 아닌 다른 모듈 옵션을 사용한다면 moduleResolution 옵션을 node로 설정해야 합니다.\n그런 다음 문제없이 Lodash를 가져올 수 있으며 자동 완성을 얻을 수 있습니다.\n모듈 내보내기 (Exporting from Modules)\n전형적으로 모듈에서 내보내기는 exports 나 module.exports와 같은 값에 프로퍼티를 추가하는 것을 포함합니다.TypeScript를 사용하면 최상위 레벨 내보내기 명령문을 허용할 수 있습니다.\n예를 들어 이와 같은 함수를 내보낸 경우:\nmodule.exports.feedPets = function(pets) {\n    // ...\n}\n\n다음과 같이 작성할 수 있습니다:\nexport function feedPets(pets) {\n    // ...\n}\n\n때로는 exports 객체를 완전히 덮어쓰기도 합니다.\n이것은 모듈을 이 코드처럼 즉시 호출 가능한 모듈로 만들기 위해 사용하는 일반적인 패턴입니다:\nvar express = require(\"express\");\nvar app = express();\n\n이전에는 이렇게 작성했을 수도 있습니다 :\nfunction foo() {\n    // ...\n}\nmodule.exports = foo;\n\nTypeScript에서는 이것을 export = 구조로 모델링할 수 있습니다.\nfunction foo() {\n    // ...\n}\nexport = foo;\n\n너무 많거나 적은 인수 (Too many/too few arguments)\n때때로 너무나 많거나 적은 인수를 가진 함수를 호출할 때가 있습니다.전형적으로 이것은 버그이지만 어떤 경우에는 매개 변수를 쓰는 대신 arguments 객체를 사용하는 함수를 선언했을 수도 있습니다:\nfunction myCoolFunction() {\n    if (arguments.length == 2 && !Array.isArray(arguments[1])) {\n        var f = arguments[0];\n        var arr = arguments[1];\n        // ...\n    }\n    // ...\n}\n\nmyCoolFunction(function(x) { console.log(x) }, [1, 2, 3, 4]);\nmyCoolFunction(function(x) { console.log(x) }, 1, 2, 3, 4);\n\n이런 경우에는 TypeScript를 사용하여 myCoolfunction이 함수 오버로드를 통해 호출될 수 있는 방법에 대해 알려주어야 합니다.\nfunction myCoolFunction(f: (x: number) => void, nums: number[]): void;\nfunction myCoolFunction(f: (x: number) => void, ...nums: number[]): void;\nfunction myCoolFunction() {\n    if (arguments.length == 2 && !Array.isArray(arguments[1])) {\n        var f = arguments[0];\n        var arr = arguments[1];\n        // ...\n    }\n    // ...\n}\n\nmyCoolFunction에 두 개의 오버로드를 추가했습니다.\n첫 번째 검사는 myCoolFunction가 (number를 갖는) 함수에 number의 목록을 가집니다.\n두번째는 함수도 갖춰야 한다는 것이고 그 뒤에 오는 인수가 숫자여야 한다는 것을 알리기 위해 나머지 매개변수(...nums)를 사용합니다.\n순차적으로 추가되는 프로퍼티 (Sequentially Added Properties)\n어떤 사람들은 다음과 같이 즉시 객체를 생성하고 속성을 추가하는 것이 더 예술적으로 즐겁다는 것을 알게됩니다:\nvar options = {};\noptions.color = \"red\";\noptions.volume = 11;\n\nTypeScript는 options의 타입을 어떠한 프로퍼티도 갖지 않는 {}로 먼저 찾아냈기 때문에 volume과 color에 할당할 수 없다고 말할 것입니다.대신 선언을 객체 리터럴 자체로 옮기면 오류가 발생하지 않습니다:\nlet options = {\n    color: \"red\",\n    volume: 11\n};\n\noptions의 타입을 정의하고 객체 리터럴에 타입 단언(type assertion)을 추가 할 수도 있습니다.\ninterface Options { color: string; volume: number }\n\nlet options = {} as Options;\noptions.color = \"red\";\noptions.volume = 11;\n\n또는 options에 any 타입이라고 하는 것이 가장 쉬운 방법이지만 가장 이득이 적은 일이 될 것입니다.\nany와 Object 그리고 {} (any, Object, and {})\n대부분의 경우 Object가 가장 일반적인 타입이기 때문에 Object 또는 {}를 사용하여 값에 프로퍼티를 포함할 수 있다고 말할 수 있습니다.하지만 any가 가장 유연한 타입이기 때문에 이러한 상황에서 실제로 사용하려는 타입입니다.\n예를 들어 Object 타입을 가지고 있다면 toLowerCase()와 같은 메서드를 호출할 수 없습니다.  \n좀 더 일반적이라는 것은 보통 타입을 사용하는 것이 적다는 것을 의미하지만 가장 일반적인 타입인 any는 여전히 어떤 것이든 할 수 있게 허용해준다는 점에서 특별합니다.즉 호출하여 구성하고 프로퍼티를 조작할 수 있습니다.하지만 any를 사용하면 TypeScript가 제공하는 대부분의 오류 검사 및 편집기 지원을 잃어 버리게 됩니다.\nObject와 {}로 판결났다면 {}을 선호해야 합니다.그것들은 대체로 같지만 비밀스러운 경우에는 기술적으로 {}가 Object보다 더 일반적인 타입입니다.\n엄격한 검사 받기 (Getting Stricter Checks)\nTypeScript는 프로그램의 안전성과 분석을 제공하기 위해 특정 검사를 제공합니다.일단 코드 베이스를 TypeScript로 변환한 후에는 이러한 검사를 활성화하여 안전성을 높일 수 있습니다.\n암시적인 any는 No (No Implicit any)\n타이프 스크립트가 어떤 타입이어야 할지 모르는 특정한 경우가 있습니다.가능하면 관대하기 위해 그 자리에 any 타입을 사용하기로 결정할 것입니다.이는 마이 그레이션에는 매우 유용하지만 any를 사용하면 어떠한 유형의 안전도 확보할 수 없으며 다른 곳에서 얻을 수 있는 것과 도구의 지원을 받을 수 없습니다.TypeScript에서 이러한 위치를 기록하도록 지시하고 noImplicitAny 옵션으로 오류를 표시할 수 있습니다.\n엄격한 null과 undefined 체크 (Strict null & undefined Checks)\n기본적으로 TypeScript는 null과 undefined이 모든 타입의 범위에 있다고 가정합니다.즉 number 타입으로 선언된 모든 것이 null 또는 undefined 일 수 있음을 의미합니다.  \nnull과 undefined는 JavaScript와 TypeScript에서 자주 발생하는 버그의 원천이기 때문에 TypeScript는 이에 대한 걱정을 덜어주기 위해 strictNullChecks 옵션을 가지고 있습니다.  \nstrictNullChecks가 활성화되면 null과 undefined는 null과 undefined 각각의 타입을 갖습니다.\n혹시 null 일 수 있는 항목이 있을 때 원래 타입을 union 타입으로 사용할 수 있습니다.그렇기 때문에 타입이 number(이)거나 null 일 수 있는 경우 해당 타입을 number | null로 쓰면 됩니다.\nTypeScript가 null /undefined라고 생각하는 값을 가지고 있지만 더 잘 알고 있다면 후위 연산자 !를 사용하여 다르게 사용할 수 있습니다.\ndeclare var foo: string[] | null;\n\nfoo.length;  // 오류 - 'foo'는 'null'일 수 있습니다.\n\nfoo!.length; // 좋아요 - 'foo!'에 'string[]'타입이 있습니다.\n\n참고로 strictNullChecks를 사용할 때는 strictNullChecks도 사용하기 위해 의존성을 업데이트해야 할 수도 있습니다.\n묵시적인 this의 any No! (No Implicit any for this)\n클래스 밖에서 this 키워드를 사용할 때 기본적으로 any 타입을 가집니다.\n예를 들어 Point 클래스를 생각하여 메서드로 추가하고자 하는 함수를 작성해보세요 :\nclass Point {\n    constructor(public x, public y) {}\n    getDistance(p: Point) {\n        let dx = p.x - this.x;\n        let dy = p.y - this.y;\n        return Math.sqrt(dx ** 2 + dy ** 2);\n    }\n}\n// ...\n\n// 인터페이스를 다시 열어보세요\ninterface Point {\n    distanceFromOrigin(point: Point): number;\n}\nPoint.prototype.distanceFromOrigin = function(point: Point) {\n    return this.getDistance({ x: 0, y: 0});\n}\n\n이것은 위에서 언급한 것과 동일한 문제를 가지고 있습니다 - getDistance의 철자가 틀리거나 오류가 발생하지 않을 수 있습니다.이러한 이유로 TypeScript는 noImplicitThis 옵션을 가지고 있습니다.이 옵션을 설정하면 TypeScript에서 명시적(또는 추론된) 타입 없이 this를 사용할 경우 오류가 발생합니다.\n해결책은 인터페이스나 함수 자체에 this-매개변수를 사용하여 명확한 타입을 제공하는 것입니다:\nPoint.prototype.distanceFromOrigin = function(this: Point, point: Point) {\n    return this.getDistance({ x: 0, y: 0});\n}\n\n"},"pages/tutorials/React & Webpack.html":{"url":"pages/tutorials/React & Webpack.html","title":"리액트 & 웹팩","keywords":"","body":"이 가이드는 TypeScript를 React 및 webpack에 연결하는 방법을 알려줍니다.\n새로운 프로젝트를 시작하는 경우, 먼저 React Quick Start guide를 살펴보세요.\n그렇지 않으면 이미 npm과 함께 Node.js를 사용하고 있다고 가정합니다.\n프로젝트 배치 (Lay out the project)\n새 디렉토리부터 시작하겠습니다.\n지금은 이름을 proj라고 지정하지만, 원하는대로 변경할 수 있습니다.\nmkdir proj\ncd proj\n\n시작하기 위해, 다음과 같은 방식으로 프로젝트를 구성하겠습니다:\nproj/\n├─ dist/\n└─ src/\n   └─ components/\n\nTypeScript 파일은 src 폴더에서 시작하여, TypeScript 컴파일러를 통해 실행한 다음, webpack을 거쳐 dist의 main.js 파일로 끝납니다.\n우리가 작성하는 모든 컴포넌트는 src/components 폴더 안에 있습니다.\n이것을 기본 뼈대로 구성합니다:\nmkdir src\ncd src\nmkdir components\ncd ..\n\nWebpack으로 마지막엔 dist폴더를 생성할 것입니다.\n프로젝트 초기화 (Initialize the project)\n이제 이 폴더를 npm 패키지로 바꿀 것 입니다.\nnpm init -y\n\n기본값으로 package.json 파일이 생성됩니다.\n의존성 설치 (Install our dependencies)\n먼저 Webpack이 설치되어 있는지 확인합니다.\nnpm install --save-dev webpack webpack-cli\n\nWebpack은 코드와 선택적으로 모든 의존성을 하나의 .js파일로 묶는 도구입니다.\n이제 선언 파일과 함께 React 및 React-DOM을 package.json 파일에 의존성으로 추가하겠습니다:\nnpm install --save react react-dom\nnpm install --save-dev @types/react @types/react-dom\n\n@types/ 접두사는 React와 React-DOM의 선언 파일을 가져오고 싶다는 것을 의미합니다.\n일반적으로 \"react\"와 같은 경로를 가져오면, react 패키지 자체를 살펴볼 것입니다;\n그러나 모든 패키지에 선언 파일이 포함되어 있지 않기 때문에, TypeScript는 @types/react 패키지도 찾습니다.\n나중에는 이것에 대해 생각할 필요가 없다는 것을 알 수 있습니다.\n다음으로, 개발 시 필요한 의존성에 ts-loader와source-map-loader를 추가합니다.\nnpm install --save-dev typescript ts-loader source-map-loader\n\n이 의존성들은  TypeScript와 Webpack을 같이 쓸 수 있게 해줍니다.\nts-loader는 Webpack이 tsconfig.json이라는 TypeScript 표준 구성 파일을 사용하여 TypeScript 코드를 컴파일하도록 도와줍니다.\nsource-map-loader는 TypeScript의 소스 맵 출력을 사용하여 고유한 소스 맵을 생성할 때 Webpack에 알립니다.\n이렇게 하면 기존의 TypeScript 소스 코드를 디버깅하는 것 처럼 최종 출력 파일을 디버깅 할 수 있습니다.\nts-loader가 TypeScript의 유일한 로더는 아님을 유의해주세요\nTypeScript를 개발 의존성으로  설치했다는 것에 유의하세요.\nnpm link typescript를 사용하여 TypeScript를 전역 복사본에 연결할 수도 있지만, 덜 일반적인 시나리오입니다.\nTypeScript 구성 파일 추가 (Add a TypeScript configuration file)\n작성하려는 코드와 필요한 선언 파일 모두 TypeScript 파일로 가져오기를 원할 것입니다.\n이렇게 하려면, 입력 파일 목록과 모든 컴파일 설정을 포함하는 tsconfig.json 파일을 만들어야 합니다.\n프로젝트 루트에 tsconfig.json이라는 새 파일을 생성하고, 다음 내용을 채우세요:\n{\n    \"compilerOptions\": {\n        \"outDir\": \"./dist/\",\n        \"sourceMap\": true,\n        \"noImplicitAny\": true,\n        \"module\": \"commonjs\",\n        \"target\": \"es6\",\n        \"jsx\": \"react\"\n    }\n}\n\ntsconfig.json 파일에 대한 자세한 내용은 여기를 참조하세요.\n코드 작성하기 (Write some code)\nReact를 사용하여 첫 번째 TypeScript 파일을 작성해 봅시다.\n먼저, src/components에 Hello.tsx 파일을 만들고 다음과 같이 작성하세요:\nimport * as React from \"react\";\n\nexport interface HelloProps { compiler: string; framework: string; }\n\nexport const Hello = (props: HelloProps) => Hello from {props.compiler} and {props.framework}!;\n\n이 예제는 함수 컴포넌트를 사용하지만, 예제를 조금 더 고급스럽게 만들 수 있습니다.\nimport * as React from \"react\";\n\nexport interface HelloProps { compiler: string; framework: string; }\n\n// 'HelloProps'는 props의 형태를 나타냅니다.\n// state는 설정되지 않으므로, `{}` 타입을 사용합니다.\nexport class Hello extends React.Component {\n    render() {\n        return Hello from {this.props.compiler} and {this.props.framework}!;\n    }\n}\n\n다음 소스를 이용하여 src에 index.tsx를 생성합니다.\nimport * as React from \"react\";\nimport * as ReactDOM from \"react-dom\";\n\nimport { Hello } from \"./components/Hello\";\n\nReactDOM.render(\n    ,\n    document.getElementById(\"example\")\n);\n\n방금 Hello 컴포넌트를 index.tsx로 가져왔습니다.\n\"react\"나 \"react-dom\"과는 달리, Hello.tsx에 대한 상대 경로를 사용했다는 것에 유의하세요. - 이것은 중요합니다.\n그렇지 않은 경우, TypeScript는 대신 node_modules 폴더를 찾았습니다.\nHello 컴포넌트를 표시할 페이지도 필요합니다.\nproj의 루트에 index.html 파일을 생성하고 다음과 같이 작성하세요:\n\n\n    \n        \n        Hello React!\n    \n    \n        \n\n        \n        \n        \n\n        \n        \n    \n\n\n우리는 node_modules 안에 들어있는 파일을 포함시킵니다.\nReact와 React-DOM의 npm 패키지에는 웹 페이지에 포함 할 수 있는 독립형 .js 파일이 있으며, 보다 빠르게 이동하기 위해 직접 찹조합니다.\n이런 파일을 다른 디렉토리에 복사하거나, CDN(Content Delivery Network)에서 호스팅합니다.\nFacebook은 CDN-호스트 버전의 React를 제공하며, 여기에서 자세한 내용을 읽을 수 있습니다.\nWebpack 구성 파일 생성하기 (Create a webpack configuration file)\n프로젝트 디렉토리의 루트에 webpack.config.js 파일을 생성합니다.\nmodule.exports = {\n    mode: \"production\",\n\n    // Webpack의 출력물에서 디버깅을 하기위해 소스 맵을 허용합니다.\n    devtool: \"source-map\",\n\n    resolve: {\n        // 확인 가능한 확장자로 '.ts' 와 '.tsx' 를 추가합니다.\n        extensions: [\".ts\", \".tsx\"]\n    },\n\n    module: {\n        rules: [\n            {\n                test: /\\.ts(x?)$/,\n                exclude: /node_modules/,\n                use: [\n                    {\n                        loader: \"ts-loader\"\n                    }\n                ]\n            },\n            // 모든 '.js' 출력 파일은 'source-map-loader'에서 다시 처리한 소스 맵이 있습니다.\n            {\n                enforce: \"pre\",\n                test: /\\.js$/,\n                loader: \"source-map-loader\"\n            }\n        ]\n    },\n\n    // 경로가 다음 중 하나와 일치하는 모듈을 가져올 때,\n    // 해당 전역 변수가 있다고 가정하고 사용합니다.\n    // 브라우저가 빌드간에 라이브러리를 캐시 할 수 있도록\n    // 모든 의존성을 묶지 않아도 되기 때문에 중요합니다.\n    externals: {\n        \"react\": \"React\",\n        \"react-dom\": \"ReactDOM\"\n    }\n};\n\nexternals 필드에 대해 궁금할 것 입니다.\n컴파일 시간이 증가하고 브라우저가 라이브러리를 변경하지 않으면, 일반적으로 라이브러리를 캐시 할 수 있기 때문에 모든 React를 동일한 파일에 묶지 않는 것이 좋습니다.\n이상적으로 브라우저 내에서 React 모듈을 가져오지만, 대부분의 브라우저는 아직 모듈을 지원하지 않습니다.\n대신 라이브러리는 전통적으로 jQuery 나 _ 와 같은 단일 전역 변수를 사용하여 사용할 수 있습니다.\n이런 방식을 \"namespace pattern\"이라고 하며, Webpack을 사용하면 이 방식으로 작성된 라이브러리를 계속 활용할 수 있습니다.\n\"react\": \"React\"를 입력하면 Webpack은 React 변수에서 \"react\"를 불러오기 위해 마법을 사용할 것 입니다.\n여기에서 Webpack 구성에 대해 자세히 알아볼 수 있습니다.\n모든 것을 함께 모아서 (Putting it all together)\n그냥 실행합니다:\nnpx webpack\n\n이제 즐겨 찾는 브라우저에서 index.html을 열고 모든 것을 사용할 준비가 되었습니다!\n\"Hello from TypeScript and React!\" 라는 페이지가 나타납니다.\n"},"pages/Basic Types.html":{"url":"pages/Basic Types.html","title":"기본 타입","keywords":"","body":"목차 (Table of Contents)\n\n소개 (Introduction)\n불리언 (Boolean)\n숫자 (Number)\n문자열 (String)\n배열 (Array)\n튜플 (Tuple)\n열거 (Enum)\nAny\nVoid\nNull and Undefined\nNever\n객체 (Object)\n타입 단언 (Type assertions)\n'let'에 관하여\n\n소개 (Introduction)\n프로그램이 유용하려면 숫자, 문자열, 구조체, 불리언 값과 같은 간단한 데이터 단위가 필요합니다.\nTypeScript는 JavaScript와 거의 동일한 데이터 타입을 지원하며, 열거 타입을 사용하여 더 편리하게 사용할 수 있습니다.\n불리언 (Boolean)\n가장 기본적인 데이터 타입은 JavaScript, TypeScript에서 boolean 값이라고 일컫는 참/거짓(true/false) 값입니다.\nlet isDone: boolean = false;\n\n숫자 (Number)\nJavaScript처럼, TypeScript의 모든 숫자는 부동 소수 값입니다.\n부동 소수에는 number라는 타입이 붙혀집니다.\nTypeScript는 16진수, 10진수 리터럴에 더불어, ECMAScript 2015에 소개된 2진수, 8진수 리터럴도 지원합니다.\nlet decimal: number = 6;\nlet hex: number = 0xf00d;\nlet binary: number = 0b1010;\nlet octal: number = 0o744;\n\n문자열 (String)\n웹 페이지, 서버 같은 프로그램을 JavaScript로 만들 때 기본적으로 텍스트 데이터를 다루는 작업이 필요합니다.\n다른 언어들처럼, TypeScript에서는 텍스트 테이터 타입을 string으로 표현합니다.\nJavaScript처럼 TypeScript도 큰따옴표 (\")나 작은따옴표 (')를 문자열 데이터를 감싸는데 사용합니다.\nlet color: string = \"blue\";\ncolor = 'red';\n\n또한 템플릿 문자열 을 사용하면 여러 줄에 걸쳐 문자열을 작성할 수 있으며, 표현식을 포함시킬 수도 있습니다.\n이 문자열은 백틱/백쿼트 (`  ) 문자로 감싸지며, ${ expr }과 같은 형태로 표현식을 포함시킬 수 있습니다.\nlet fullName: string = `Bob Bobbington`;\nlet age: number = 37;\nlet sentence: string = `Hello, my name is ${ fullName }.\nI'll be ${ age + 1 } years old next month.`;\n\n위는 아래 sentence선언과 동일합니다:\nlet sentence: string = \"Hello, my name is \" + fullName + \".\\n\\n\" +\n    \"I'll be \" + (age + 1) + \" years old next month.\";\n\n배열 (Array)\nTypeScript는 JavaScript처럼 값들을 배열로 다룰 수 있게 해줍니다.\n배열 타입은 두 가지 방법으로 쓸 수 있습니다.\n첫 번째 방법은, 배열 요소들을 나타내는 타입 뒤에 []를 쓰는 것입니다:\nlet list: number[] = [1, 2, 3];\n\n두 번째 방법은 제네릭 베열 타입을 쓰는 것입니다. Array:\nlet list: Array = [1, 2, 3];\n\n튜플 (Tuple)\n튜플 타입을 사용하면, 요소의 타입과 개수가 고정된 배열을 표현할 수 있습니다. 단 요소들의 타입이 모두 같을 필요는 없습니다. 예를 들어, number, string 이 쌍으로 있는 값을 나타내고 싶을 수 있습니다:\n// 튜플 타입으로 선언\nlet x: [string, number];\n// 초기화\nx = [\"hello\", 10]; // 성공\n// 잘못된 초기화\nx = [10, \"hello\"]; // 오류\n\n정해진 인덱스에 위치한 요소에 접근하면 해당 타입이 나타납니다.\nconsole.log(x[0].substring(1)); // 성공\nconsole.log(x[1].substring(1)); // 오류, 'number'에는 'substring' 이 없습니다.\n\n정해진 인덱스 외에 다른 인덱스에 있는 요소에 접근하면, 오류가 발생하며 실패합니다.\nx[3] = \"world\"; // 오류, '[string, number]' 타입에는 프로퍼티 '3'이 없습니다.\n\nconsole.log(x[5].toString()); // '[string, number]' 타입에는 프로퍼티 '5'가 없습니다.\n\n열거 (Enum)\nJavaScript의 표준 자료형 집합과 사용하면 도움이 될만한 데이터 형은 enum입니다.\nC# 같은 언어처럼, enum은 값의 집합에 더 나은 이름을 붙여줄 수 있습니다.\nenum Color {Red, Green, Blue}\nlet c: Color = Color.Green;\n\n기본적으로, enum은 0부터 시작하여 멤버들의 번호를 매깁니다.\n멤버 중 하나의 값을 수동으로 설정하여 번호를 바꿀 수 있습니다.\n예를 들어, 위 예제를 0대신 1부터 시작해 번호를 매기도록 바꿀 수 있습니다.\nenum Color {Red = 1, Green, Blue}\nlet c: Color = Color.Green;\n\n또는, 모든 값을 수동으로 설정할 수 있습니다:\nenum Color {Red = 1, Green = 2, Blue = 4}\nlet c: Color = Color.Green;\n\nenum의 유용한 기능 중 하나는 매겨진 값을 사용해 enum 멤버의 이름을 알아낼 수 있다는 것입니다.\n예를 들어, 위의 예제에서 2라는 값이 위의 어떤 Color enum 멤버와 매칭되는지 알 수 없을 때, 이에 일치하는 이름을 알아낼 수 있습니다:\nenum Color {Red = 1, Green, Blue}\nlet colorName: string = Color[2];\n\nconsole.log(colorName); // 값이 2인 'Green'이 출력됩니다.\n\nAny\n애플리케이션을 만들 때, 알지 못하는 타입을 표현해야 할 수도 있습니다.\n이 값들은 동적인 콘텐츠에서 올 수도 있습니다. 예) 사용자로부터 받은 데이터. 혹은 3rd party library.\n이 경우 타입 검사를 하지 않고, 그 값들이 컴파일 시간에 검사를 통과하길 원합니다.\n이를 위해, any 타입을 사용할 수 있습니다:\nlet notSure: any = 4;\nnotSure = \"maybe a string instead\";\nnotSure = false; // 성공, 분명히 부울입니다.\n\nany 타입은 기존에 JavaScript로 작업할 수 있는 강력한 방법으로, 컴파일 중에 점진적으로 타입 검사를 하거나 하지 않을 수 있습니다.\n혹 다른 언어에서 그렇듯, Object가 비슷한 역할을 할 수 있을 것 같다고 생각할 수도 있습니다.\n그런데, Object로 선언된 변수들은 오직 어떤 값이든 그 변수에 할당할 수 있게 해주지만 실제로 메서드가 존재하더라도, 임의로 호출할 수는 없습니다:\nlet notSure: any = 4;\nnotSure.ifItExists(); // 성공, ifItExists 는 런타임엔 존재할 것입니다.\nnotSure.toFixed(); // 성공, toFixed는 존재합니다. (하지만 컴파일러는 검사하지 않음)\n\nlet prettySure: Object = 4;\nprettySure.toFixed(); // 오류: 프로퍼티 'toFixed'는 'Object'에 존재하지 않습니다.\n\n\nNote: Do's and Don'ts에 설명 했듯이 Object를 no-primitive object 대신에 사용하지 마세요.\n\n또한, any 타입은 타입의 일부만 알고 전체는 알지 못할 때 유용합니다.\n예를 들어, 여러 다른 타입이 섞인 배열을 다룰 수 있습니다.\nlet list: any[] = [1, true, \"free\"];\n\nlist[1] = 100;\n\nVoid\nvoid는 어떤 타입도 존재할 수 없음을 나타내기 때문에, any의 반대 타입 같습니다.\nvoid는 보통 함수에서 반환 값이 없을 때 반환 타입을 표현하기 위해 쓰이는 것을 볼 수 있습니다:\nfunction warnUser(): void {\n    console.log(\"This is my warning message\");\n}\n\nvoid를 타입 변수를 선언하는 것은 유용하지 않은데, 왜냐하면 그 변수에는 null(--strictNullChecks을 사용하지 않을 때만 해당, 자세한 건 다음 섹션을 참고)또는 undefined 만 할당할 수 있기 때문입니다:\nlet unusable: void = undefined;\nunusable = null; // 성공  `--strictNullChecks` 을 사용하지 않을때만\n\nNull and Undefined\nTypeScript는 undefined 과 null 둘 다 각각 자신의 타입 이름으로 undefined , null로 사용합니다.\nvoid처럼 그 자체로 유용한 경우는 거의 없습니다:\n// 이 밖에 이 변수들에 할당할 수 있는 값이 없습니다!\nlet u: undefined = undefined;\nlet n: null = null;\n\n기본적으로 null 과 undefined는 다른 모든 타입의 하위 타입니다.\n이건, null과 undefined를 number 같은 타입에 할당할 수 있다는 것을 의미합니다.\n하지만, --strictNullChecks를 사용하면, null과  undefined는 오직 any와 각자 자신들 타입에만 할당 가능합니다. (예외적으로 undefined는 void에 할당 가능합니다)\n이건 많은 일반적인 에러를 방지하는 데 도움을 줍니다.\n이 경우, string 또는 null 또는 undefined를 허용하고 싶은 경우 유니언 타입인 string | null | undefined를 사용할 수 있습니다.\n유니언 타입은 상급 주제로, 이후 챕터에서 다룹니다.\n\nAs a note: 가능한 경우 --structNullChecks를 사용할 것을 권장합니다. 하지만 핸드북의 목적에 따라, 사용하지 않는다고 가정합니다.\n\nNever\nnever 타입은 절대 발생할 수 없는 타입을 나타냅니다.\n예를 들어, never는 함수 표현식이나 화살표 함수 표현식에서 항상 오류를 발생시키거나 절대 반환하지 않는 반환 타입으로 쓰입니다.\n변수 또한 타입 가드에 의해 아무 타입도 얻지 못하게 좁혀지면 never 타입을 얻게 될 수 있습니다.\nnever타입은 모든 타입에 할당 가능한 하위 타입입니다. 하지만 어떤 타입도 never에 할당할 수 있거나, 하위 타입이 아닙니다.(never 자신은 제외)\n심지어 any 도 never에 할당할 수 없습니다.\nnever를 반환하는 몇 가지 예제입니다:\n// never를 반환하는 함수는 함수의 마지막에 도달할 수 없다.\nfunction error(message: string): never {\n    throw new Error(message);\n}\n\n// 반환 타입이 never로 추론된다.\nfunction fail() {\n    return error(\"Something failed\");\n}\n\n// never를 반환하는 함수는 함수의 마지막에 도달할 수 없다.\nfunction infiniteLoop(): never {\n    while (true) {\n    }\n}\n\n객체 (Object)\nobject는 원시 타입이 아닌 타입을 나타냅니다. 예를 들어, number, string, boolean, bigint, symbol, null, 또는 undefined 가 아닌 나머지를 의미합니다.\nobject 타입을 쓰면, Object.create 같은 API 가 더 잘 나타납니다. 예를 들어:\ndeclare function create(o: object | null): void;\n\ncreate({ prop: 0 }); // 성공\ncreate(null); // 성공\n\ncreate(42); // 오류\ncreate(\"string\"); // 오류\ncreate(false); // 오류\ncreate(undefined); // 오류\n\n타입 단언 (Type assertions)\n가끔, TypeScript보다 개발자가 값에 대해 더 잘 알고 일을 때가 있습니다.\n대개, 이런 경우는 어떤 엔티티의 실제 타입이 현재 타입보다 더 구체적일 때 발생합니다.\n타입 단언(Type assertions) 은 컴파일러에게 \"날 믿어, 난 내가 뭘 하고 있는지 알아\"라고 말해주는 방법입니다.\n타입 단언은 다른 언어의 타입 변환(형 변환)과 유사하지만, 다른 특별한 검사를 하거나 데이터를 재구성하지는 않습니다.\n이는 런타임에 영향을 미치지 않으며, 온전히 컴파일러만 이를 사용합니다.\n타입 스크립트는 개발자가 필요한 어떤 특정 검사를 수행했다고 인지합니다.\n타입 단언에는 두 가지 형태가 있습니다.\n하나는, \"angle-bracket\" 문법입니다:\nlet someValue: any = \"this is a string\";\n\nlet strLength: number = (someValue).length;\n\n다른 하나는 as-문법 입니다.\nlet someValue: any = \"this is a string\";\n\nlet strLength: number = (someValue as string).length;\n\n위 두 예제는 동일합니다.\n어떤 것을 사용할지는 주로 선호에 따른 선택입니다. 하지만 TypeScript를 JSX와 함께 사용할 때는, as-스타일의 단언만 허용됩니다.\nlet에 관하여\n지금까지 더 익숙할 수도 있는 JavaScript의 var 키워드 대신 let 키워드를 이용했다는 걸 알 수 있습니다.\nlet 키워드는 JavaScript ES2015에서 소개되었고, var보다 안전하다는 이유로, 현재 표준으로 여겨지고 있습니다.\n나중에 더 자세히 살펴보겠지만, 대부분의 JavaScript의 문제들이 let을 사용해서 해결되며, 때문에 가능한 경우 최대한 var대신 let을 사용하셔야 합니다.\n"},"pages/Variable Declarations.html":{"url":"pages/Variable Declarations.html","title":"변수 선언","keywords":"","body":"변수 선언 (Variable Declarations)\nlet과 const는 JavaScript에서 비교적 새로운 두 가지 유형의 변수 선언입니다.\n앞에서 언급했듯이, let은 var와 어느 정도 유사하지만, 사용자가 JavaScript에서 자주 마주치는 결함을 피할 수 있게 해줍니다.\nconst는 let의 기능이 강화된 것으로 변수에 재할당을 방지합니다.\nTypeScript는 JavaScript의 상위 집합이므로, 당연히 let과 const를 지원합니다.\n여기서는 새로운 선언 방식들과 왜 그 방식들이 var보다 선호되는지를 더 자세히 설명합니다.\nJavaScript를 아무렇게나 사용하고 있었다면, 다음 섹션이 기억을 새로 고치도록 도와줄 것입니다.\nJavaScript에서 var 선언의 단점들에 대해 모두 알고 있다면 쉽게 넘어갈 수 있습니다.\nvar 선언 (var declarations)\n기존 JavaScript에서는 변수 선언을 할 때 var 키워드를 사용했습니다.\nvar a = 10;\n\n알다시피, a라는 변수를 10이라는 값으로 선언했습니다.\n또한, 변수를 함수 내부에 선언할 수도 있습니다.\nfunction f() {\n    var message = \"Hello, world!\";\n\n    return message;\n}\n\n그리고, 같은 변수를 다른 함수 안에서 접근할 수도 있습니다.\nfunction f() {\n    var a = 10;\n    return function g() {\n        var b = a + 1;\n        return b;\n    }\n}\n\nvar g = f();\ng(); // '11'을 반환\n\n위 예제에서, g는 f 안에 선언된 a를 잡아 둡니다.\n언제든 g가 호출될 때, a의 값은 f 안의 a 값을 가리킵니다.\nf가 실행되면서 g가 한번 호출된 후에도, a에 접근해 수정할 수 있습니다.\nfunction f() {\n    var a = 1;\n\n    a = 2;\n    var b = g();\n    a = 3;\n\n    return b;\n\n    function g() {\n        return a;\n    }\n}\n\nf(); // '2' 반환\n\n스코프 규칙 (Scoping rules)\nvar 선언은 다른 언어와 다른 이상한 스코프 규칙들을 가지고 있습니다.\n아래 예제를 살펴보겠습니다:\nfunction f(shouldInitialize: boolean) {\n    if (shouldInitialize) {\n        var x = 10;\n    }\n\n    return x;\n}\n\nf(true);  // '10' 반환\nf(false); // 'undefined' 반환\n\n이 예제에서, 어떤 분들은 머뭇거릴 수도 있습니다.\n변수 x는 if 블록 안에 선언되어 있지만, 블록의 바깥에서도 이 변수에 접근할 수 있습니다.\n이 이유는 var선언은 이를 감싸고 있는 블록과 관계없이 이를 감싸고 있는 함수, 모듈, 네임스페이스, 전역 스코프에서 접근할 수 있기 때문입니다.\n어떤 이는 이를 var-스코프 혹은 함수 스코프라고 부릅니다.\n매개 변수 또한 함수 스코프입니다.\n이런 스코프 규칙은 몇 가지 실수를 유발할 수 있습니다.\n더욱 문제를 심각하게 하는 것은 변수를 여러 번 선언하는 것이 에러가 아니라는 것입니다:\nfunction sumMatrix(matrix: number[][]) {\n    var sum = 0;\n    for (var i = 0; i \n아마 쉽게 찾을 수 있겠지만, i가 같은 함수 스코프의 변수를 참조하고 있기 때문에 for-loop 안에서 실수로 변수 i를 덮어쓸 수도 있습니다\n경험 많은 개발자는 바로 알아차리겠지만, 비슷한 종류의 버그는 코드 리뷰를 거치며 좌절의 원인이 되기도 합니다.\n변수 캡쳐링의 단점 (Variable capturing quirks)\n다음 코드의 출력 결과를 예상해 보세요:\nfor (var i = 0; i \n익숙하지 않은 분들을 위해 말씀드리자면, setTimeout은 특정 밀리 초 후에 함수를 실행합니다.(다른 작업의 실행이 멈추는 것을 기다리며)\n준비됐나요? 살펴보겠습니다:\n10\n10\n10\n10\n10\n10\n10\n10\n10\n10\n\n많은 JavaScript 개발자들은 이런 동작에 익숙한 편이지만, 만약 놀랐더라도 당신 혼자만 놀란 것은 아닙니다.\n많은 사람들이 출력 결과가 다음과 같을 거라고 생각합니다.\n0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n\n앞서 변수 캡쳐링에 대해 언급했던 부분을 기억하나요?\nsetTimout에 전달하는 모든 함수 표현식은 사실 같은 스코프에서 같은 i를 참조합니다.\n잠시, 이게 무슨 뜻인지 생각해 보세요.\nsetTimeout은 함수를 몇 밀리 초 후에 실행 시키겠지만. 항상for루프가 실행을 멈추고 난 뒤에 실행됩니다.\nfor 루프가 실행을 중지했을 때, i의 값은 10입니다.\n따라서 매번 주어진 함수가 호출될 때마다 10을 출력할 것입니다.\n일반적으로 이를 동작하게 하는 방법은 즉시 실행 함수(IIFE - an Immediately Invoked Function Expression)를 사용해 매 반복마다 i를 잡아두는 것입니다:\nfor (var i = 0; i \n이런 이상해 보이는 패턴이 사실 일반적인 패턴입니다.\n매개변수에 i가 for 루프의 i를 감춰 버립니다. 하지만 이름을 같게 했기 때문에 루프의 실행 부를 크게 수정할 필요가 없습니다.\nlet 선언 (let declarations)\n이제, var에  몇 가지 문제점에 대해 알게 되었는데, 이런 이유 때문에 let을 도입하게 되었습니다.\n사용되는 키워드를 빼고는 let 문은 var와 동일한 방법으로 작성됩니다.\nlet hello = \"Hello!\";\n\n주요한 차이점은 구문 보단 의미에 있는데, 이제 이 내용을 살펴볼 것입니다.\n블록 스코프 (Block-scoping)\n변수가 let을 이용해 선언되었을 때, 이는 렉시컬 스코핑(lexical-scoping) 혹은 블록 스코핑(block-scoping) 이라 불리는 것을 사용합니다.\nvar로 선언된 변수가 이를 포함한 함수까지 흘러나오는 것과 달리, 블록-스코프 변수들은 이를 가장 가깝게 감싸고 있는 블록 혹은 for-루프 밖에서 접근할 수 없습니다.\nfunction f(input: boolean) {\n    let a = 100;\n\n    if (input) {\n        // 'a'를 참조할 수 있습니다.\n        let b = a + 1;\n        return b;\n    }\n\n    // 오류: 'b'는 여기서 존재하지 않습니다.\n    return b;\n}\n\n여기, 두 지역 변수 a와 b가 있습니다.\na의 스코프는 f의 블록으로 한정되지만, b는 이를 감싸고 있는 if문의 블록까지로 한정됩니다.\ncatch 문에 선언된 변수 또한 비슷한 스코프 규칙을 가집니다.\ntry {\n    throw \"oh no!\";\n}\ncatch (e) {\n    console.log(\"Oh well.\");\n}\n\n// 오류: 'e'는 여기서 존재하지 않습니다.\nconsole.log(e);\n\n또 다른 블록-스코프 변수의 특징은 변수들이 선언되기 전에 읽거나, 쓰는 것이 불가능하다는 것입니다.\n이 변수들은 스코프에 걸쳐 \"존재\"하지만, 선언되는 부분 전까지 모든 부분들이 temploral dead zone입니다.\n이것은 let문 이전에 변수들에 접근할 수 없다는 정교한 방식이며, 다행히 TypeScript가 알려줍니다.\na++; // `a`가 선언되기 전에 잘못된 사용.\nlet a;\n\n주의할 점은 여전히 선언되기 전에 블록-스코프 변수를 잡아둘 수 있다는 것입니다.\n선언되기 전에 함수를 실행하는 것이 안된 다는 것만 알아두면 됩니다.\nES2015를 대상으로한, 최신 런타임은 오류를 던질 것입니다; 하지만 현재 TypeScript에서는 허용되며, 오류를 보고하지 않습니다.\nfunction foo() {\n    // 'a' 캡처는 성공\n    return a;\n}\n\n// `a`가 선언되기 전에 `foo` 를 호출\n// 런타임에 오류를 던질 것 입니다.\nfoo();\n\nlet a;\n\ntemporal dead zone에 더 자세한 설명은 Mozilla Developer Network를 살펴보세요.\n재선언과 쉐도잉 (Re-declarations and Shadowing)\nvar로 선언하면 얼마나 변수를 많이 선언하는지는 중요하지 않다고 했습니다. 단 하나만 생성됩니다.\nfunction f(x) {\n    var x;\n    var x;\n\n    if (true) {\n        var x;\n    }\n}\n\n위 예제를 보면 모든 x의 선언은 사실 같은 x를 가르치며, 이는 유효합니다.\n이건 종종 버그의 원인이 됩니다.\n고맙게도, let선언은 이것을 허용하지 않습니다.\nlet x = 10;\nlet x = 20; // 오류: 'x'를 같은 스코프에 선언할 수 없습니다.\n\nTypeScript가 문제를 알려주기 때문에, 변수를 반드시 블록 범위로 지정할 필요는 없습니다.\nfunction f(x) {\n    let x = 100; // 오류: 매개 변수 선언을 방해합니다.\n}\n\nfunction g() {\n    let x = 100;\n    var x = 100; // 오류: `x`를 중복해서 선언할 수 없습니다.\n}\n\n블록-스코프 변수가 함수-스코프 변수로 선언될 수 없다는 것은 아닙니다.\n블록 스코프 변수는 단지 별개의 다른 블록에 선언되어야 합니다.\nfunction f(condition, x) {\n    if (condition) {\n        let x = 100;\n        return x;\n    }\n\n    return x;\n}\n\nf(false, 0); // '0' 반환\nf(true, 0);  // '100' 반환\n\n더 중첩된 스코프에서 바깥 스코프의 변수 이름을 사용하는 것을 shadowing이라고 합니다.\nshadowing은 양날의 검이라고 할 수 있는데, 이는 실수로 방생되어 특정 버그를 일으키거나, 혹은 특정 버그를 막기 위해 쓰이기 때문입니다.\n예를 들어, 위에서 사용했던 sumMatrix 함수를 let 을 이용해서 작성했다고 생각해 봅시다.\nfunction sumMatrix(matrix: number[][]) {\n    let sum = 0;\n    for (let i = 0; i \n이 루프는 합을 올바르게 계산할 것입니다. 왜냐하면 안쪽 루프의 i 가 바깥 루프의 i를 가리기 때문입니다.\n보통 더 명확한 코드 작성을 위해 shadowing 사용을 피합니다.\n하지만 shadowing의 이점을 활용할 수 있는 적합한 상황이 있으므로, 최선의 판단을 내려야 합니다.\n블록 스코프 변수 캡쳐링 (Block-scoped variable capturing)\nvar 선언에 변수 캡쳐링을 하는 것을 처음 보았을 때, 변수가 한번 캡쳐되면 어떻게 동작하는지 간단히 살펴보았습니다.\n이를 더 잘 이해해 보면, 스코프가 각각 실행될 때마다 변수의 \"환경\"을 만듭니다.\n변수의 환경과 캡쳐된 변수들은 심지어 스코프가 포함한 모든 것이 실행을 종료한 후에도 존재합니다.\nfunction theCityThatAlwaysSleeps() {\n    let getCity;\n\n    if (true) {\n        let city = \"Seattle\";\n        getCity = function() {\n            return city;\n        }\n    }\n\n    return getCity();\n}\n\ncity를 해당 환경 안에 캡쳐했기 때문에, if 블록의 실행이 완료되었음에도 여전히 city에 접근할 수 있습니다.\n앞의 setTimeout 예제에서, for 루프가 매번 반복될 때마다 변수를 캡쳐하기 위해서 IIFE를 사용했던 것을 떠올려 봅시다.\n실제론, 캡처된 변수를 위해 새로운 변수 환경을 만드는 것이었습니다.\n이는 약간의 고통스러운 일이지만, 다행히, 타입스크립트 에서는 그렇게 할필요가 없습니다.\nlet 선언은 루프의 일부로 선언될 때 동작이 크게 다릅니다.\n이 선언은 루프 자체에 새로운 환경을 만드는 대신, 반복마다 새로운 환경을 만들어 냅니다.\n어쨋든 이건 IIFE를 통해 하고 있었던 동작이므로, 이전 setTimeout예제를 let선언만 사용해서 바꿀수 있습니다.\nfor (let i = 0; i \n그리고 예상 했던 대로, 다음과 같은 결과가 출력됩니다.\n0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n\nconst 선언 (const declarations)\nconst 선언은 변수를 선언하는 또 다른 방법입니다.\nconst numLivesForCat = 9;\n\n이 방법은 let 선언과 비슷하지만 그 이름에서 말해주듯이, 일단 바인딩 되면 값을 변경할 수 없습니다.\n다른 말로 const는 let과 같은 스코프 규칙을 가지고 있지만, 재할당 할 수 없습니다.\n이를 const가 참조하는 값이 불변이라고 혼동하면 안 됩니다.\nconst numLivesForCat = 9;\nconst kitty = {\n    name: \"Aurora\",\n    numLives: numLivesForCat,\n}\n\n// 오류\nkitty = {\n    name: \"Danielle\",\n    numLives: numLivesForCat\n};\n\n// 모두 \"성공\"\nkitty.name = \"Rory\";\nkitty.name = \"Kitty\";\nkitty.name = \"Cat\";\nkitty.numLives--;\n\n위와 같은 상황을 피하기 위해 특별한 조치를 취하지 않는 한, const 변수의 내부 상태는 여전히 수정 가능합니다.\n다행히, TypeScript를 사용하면 객체의 멤버가 읽기 전용(readonly)이라고 지정할 수 있습니다.\nInterfaces 챕터에 자세히 설명되어 있습니다.\nlet vs. const\n유사한 스코프의 의미를 가지는 두 가지 유형의 변수 선언이 있기 때문에, 어느 것을 사용하는지는 스스로 선택해야 합니다.\n광범위한 질문처럼, 답은 '때에 따라 다르다'입니다.\n최소 권한의 원칙을 적용하면, 수정하려는 선언 이외에 모든 선언은 const를 사용해야 합니다.\n그 이유는, 만약 변수가 수정될 필요가 없다면 같은 코드베이스에서 작업하는 다른 사람들이 자동으로 객체를 수정할 수 없어야 하고, 그들이 정말 변수에 재할당할 필요가 있는지 고려할 필요가 있습니다.\nconst를 사용하는 것은 데이터의 흐름을 추론할 때 코드를 더 예측하기 쉽게 해줍니다.\n최선의 판단을 하고 해당되는 경우, 팀원들과 문제에 대해 상의하세요.\n이 핸드북은 대부분 let 선언을 사용합니다.\n구조 분해 (Destructuring)\nTypeScript가 가진 또 다른 ECMAScript 2015 특징은 구조 분해입니다.\n자세한 내용은, Mozilla Developer Network의 글을 참고 하세요.\n이번 섹션에서는 간단하게 개요를 살펴보겠습니다.\n배열 구조 분해 (Array destructuring)\n구조 분해의 가장 단순한 형태는 배열 구조 분해 할당입니다:\nlet input = [1, 2];\nlet [first, second] = input;\nconsole.log(first); // 1 출력\nconsole.log(second); // 2 출력\n\n이는 first, second라는 이름의 새로운 두 변수를 생성합니다.\n이는 인덱싱을 사용하는 것과 동일하지만 더 편리합니다:\nfirst = input[0];\nsecond = input[1];\n\n구조 분해 할당은 이미 선언된 변수에도 동작합니다:\n// 변수를 스왑\n[first, second] = [second, first];\n\n그리고, 함수의 매개변수에도 동작합니다:\nfunction f([first, second]: [number, number]) {\n    console.log(first);\n    console.log(second);\n}\nf([1, 2]);\n\n나머지 요소들에 대해 ... 구문을 사용하여 변수를 생성할 수 있습니다:\nlet [first, ...rest] = [1, 2, 3, 4];\nconsole.log(first); // 1 출력\nconsole.log(rest); // [ 2, 3, 4 ] 출력\n\n물론 JavaScript이기 때문에, 필요하지 않은 뒤따라 오는 요소들을 무시할 수 있습니다:\nlet [first] = [1, 2, 3, 4];\nconsole.log(first); // 1 출력\n\n또는 그 밖에 요소들을 무시할 수 있습니다:\nlet [, second, , fourth] = [1, 2, 3, 4];\nconsole.log(second); // 2 출력\nconsole.log(fourth); // 4 출력\n\n튜플 구조 분해 (Tuple destructuring)\n튜플은 배열처럼 구조 분해됩니다; 구조 분해된 변수는 튜플 요소와 일치하는 타입을 얻게 됩니다:\nlet tuple: [number, string, boolean] = [7, \"hello\", true];\n\nlet [a, b, c] = tuple; // a: number, b: string, c: boolean\n\n튜플의 범위를 넘어선 구조 분해는 오류입니다:\nlet [a, b, c, d] = tuple; // 오류, 인덱스 3에 요소가 없습니다.\n\n배열과 마찬가지로, 더 짧은 튜플을 얻기 위해 ...로 튜플의 나머지를 구조 분해할 수 있습니다.\nlet [a, ...bc] = tuple; // bc: [string, boolean]\nlet [a, b, c, ...d] = tuple; // d: [], 비어있는 튜플\n\n또는 뒤따라 오는 요소나 다른 요소를 무시할 수 있습니다:\nlet [a] = tuple; // a: number\nlet [, b] = tuple; // b: string\n\n객체 구조 분해 (Object destructuring)\n또한 객체를 구조 분해할 수 있습니다:\nlet o = {\n    a: \"foo\",\n    b: 12,\n    c: \"bar\"\n};\nlet { a, b } = o;\n\n이는 o.a, o.b로 부터 새로운 변수 a와 b를 생성합니다.\n필요 없다면 c를 건너 뛸 수 있다는 걸 알아두세요.\n배열 구조 분해처럼, 선언 없이 할당할 수 있습니다.:\n({ a, b } = { a: \"baz\", b: 101 });\n\n이 구문을 괄호로 감싸고 있다는 것을 주의해 주세요.\nJavaScript는 보통 {를 블록의 시작으로 파싱 합니다.\n객체 안에 나머지 요소들을 ... 구문을 사용하여 변수로 생성할 수 있습니다:\nlet { a, ...passthrough } = o;\nlet total = passthrough.b + passthrough.c.length;\n\n프로퍼티 이름 바꾸기 (Property renaming)\n프로퍼티들에 다른 이름을 붙히는 것도 가능합니다.\nlet { a: newName1, b: newName2 } = o;\n\n여기서 구문이 혼란스러워지기 시작합니다.\na: newName1 을 \"a를 newName1 로\" 와 같이 읽을 수 있습니다.\n여태 써왔던 것 처럼 방향은 왼쪽에서 오른쪽입니다:\nlet newName1 = o.a;\nlet newName2 = o.b;\n\n혼란스럽게도 여기서 콜론은 타입을 나타내지 않습니다.\n타입을 지정하는 경우, 전체 구조 분해 뒤에 작성해야 합니다:\nlet { a, b }: { a: string, b: number } = o;\n\n기본 값 (Default values)\n기본 값은 프로퍼티가 정의되지 않았을 때 기본값을 사용하도록 하는 것입니다:\nfunction keepWholeObject(wholeObject: { a: string, b?: number }) {\n    let { a, b = 1001 } = wholeObject;\n}\n\n예제에서 b?는 b가 선택적이라는 것을 의미합니다. 따라서 이는 undefined 일 수도 있습니다.\nkeepWholeObject는 이제 b가 undefined 이더라도 a, b 프로퍼티와 함께 wholeObject라는 변수를 가집니다.\n함수 선언 (Function declarations)\n구조 분해는 함수 선언에서도 동작합니다.\n이것은 간단한 경우에는 직관적입니다:\ntype C = { a: string, b?: number }\nfunction f({ a, b }: C): void {\n    // ...\n}\n\n그러나 매개 변수에는 기본값을 명시하는 것이 더 일반적이며, 구조 분해와 함께 기본값을 제대로 사용하는 것은 까다로울 수 있습니다.\n가장 먼저, 구조 분해 패턴을 기본값 앞에 넣어야 한다는 것을 기억해야 합니다.\nfunction f({ a=\"\", b=0 } = {}): void {\n    // ...\n}\nf();\n\n\n위 코드는 타입 추론의 예제이며 이후 핸드북에서 설명합니다.\n\n그런 다음, 선택적 프로퍼티를 위해 기본 초기화 대신 구조 분해될 프로퍼티에 기본 값을 주어야 한다는 걸 기억해야 합니다.\nC 가 b를 선택적으로 정의했다는 것을 기억하세요:\nfunction f({ a, b = 0 } = { a: \"\" }): void {\n    // ...\n}\nf({ a: \"yes\" }); // 성공, 기본값으로 b = 0 입니다.\nf(); // 성공, 기본 값은 { a: \"\" } 이고 b = 0 입니다.\nf({}); // 오류, 매개 변수가 주어지면 `a`가 필요합니다.\n\n구조 분해를 주의해서 사용하세요.\n앞에 예제에서 알 수 있듯이, 가장 간단한 구조 분해 표현식 이외의 것들은 혼란스럽습니다.\n심지어 이름 변경, 기본값, 타입 표시가 없더라도 깊게 중첩된 구조 분해는 정말 이해하기가 힘듭니다.\n구조 분해 표현식을 작고 간단하게 유지하세요.\n당신은 언제나 구조 분해가 만드는 과제를 당신 손으로 만들 수 있습니다.\n전개 (Spread)\n전개 연산자는 구조 분해와 반대입니다.\n이는 배열을 다른 배열 안에, 혹은 객체를 다른 객체 안에 전개하도록 해줍니다.\n예를 보겠습니다:\nlet first = [1, 2];\nlet second = [3, 4];\nlet bothPlus = [0, ...first, ...second, 5];\n\n이는 bothPlus에 [0, 1, 2, 3, 4, 5]라는 값을 줍니다.\n전개는 first와 second의 얕은 복사를 만듭니다.\n이들은 전개에 의해 변하지 않습니다.\n또한 객체를 전개할 수 있습니다:\nlet defaults = { food: \"spicy\", price: \"$$\", ambiance: \"noisy\" };\nlet search = { ...defaults, food: \"rich\" };\n\n여기서 search는 { food: \"rich\", price: \"$$\", ambiance: \"noisy\" }입니다.\n객체 전개는 배열 전개보다 훨씬 복잡합니다.\n배열 전개처럼 왼쪽에서-오른쪽으로 진행되지만 그 결과는 여전히 객체입니다.\n이는 전개 객체 안에서 나중에 오는 프로퍼티가 이전에 오는 프로퍼티를 덮어쓰는 것을 의미합니다.\n그래서 만약에 우리가 이전 예제를 마지막에 전개하도록 수정하면:\nlet defaults = { food: \"spicy\", price: \"$$\", ambiance: \"noisy\" };\nlet search = { food: \"rich\", ...defaults };\n\ndefaults안에 food 프로퍼티는 food: \"rich\"를 덮어쓰는데, 이 경우 우리가 의도한 것은 아닙니다.\n객체 전개는 또한 몇몇의 놀라운 제한점이 잇습니다.\n첫째로, 이는 오직 객체\n본인의 열거 가능한 프로퍼티만 해당한다는 것입니다.\n기본적으로, 이는 객체의 인스턴스를 전개하면 메서드를 잃게 된다는 것을 뜻합니다:\nclass C {\n  p = 12;\n  m() {\n  }\n}\nlet c = new C();\nlet clone = { ...c };\nclone.p; // 성공\nclone.m(); // 오류!\n\n두 번째로, TypeScript 컴파일러는 제네릭 함수에서 타입 매개변수를 전개하는 것을 허용하지 않습니다.\n이 기능은 이후 버전에서 예상되는 기능입니다.\n"},"pages/Interfaces.html":{"url":"pages/Interfaces.html","title":"인터페이스","keywords":"","body":"소개 (Introduction)\nTypeScript의 핵심 원칙 중 하나는 타입 검사가 값의 형태에 초점을 맞추고 있다는 것입니다.\n이를 \"덕 타이핑(duck typing)\" 혹은 \"구조적 서브타이핑 (structural subtyping)\"이라고도 합니다.\nTypeScript에서, 인터페이스는 이런 타입들의 이름을 짓는 역할을 하고 코드 안의 계약을 정의하는 것뿐만 아니라 프로젝트 외부에서 사용하는 코드의 계약을 정의하는 강력한 방법입니다.\n첫 번째 인터페이스 (Our First Interface)\n어떻게 인터페이스가 동작하는지 확인하는 가장 쉬운 방법은 간단한 예제로 시작하는 것입니다:\nfunction printLabel(labeledObj: { label: string }) {\n    console.log(labeledObj.label);\n}\n\nlet myObj = {size: 10, label: \"Size 10 Object\"};\nprintLabel(myObj);\n\n타입 검사는 printLabel 호출을 확인합니다.\nprintLabel 함수는 string 타입 label을 갖는 객체를 하나의 매개변수로 가집니다.\n이 객체가 실제로는 더 많은 프로퍼티를 갖고 있지만, 컴파일러는 최소한 필요한 프로퍼티가 있는지와 타입이 잘 맞는지만 검사합니다.\nTypeScript가 관대하지 않은 몇 가지 경우는 나중에 다루겠습니다.\n이번엔 같은 예제를, 문자열 타입의 프로퍼티 label을 가진 인터페이스로 다시 작성해 보겠습니다:\ninterface LabeledValue {\n    label: string;\n}\n\nfunction printLabel(labeledObj: LabeledValue) {\n    console.log(labeledObj.label);\n}\n\nlet myObj = {size: 10, label: \"Size 10 Object\"};\nprintLabel(myObj);\n\nLabeledValue 인터페이스는 이전 예제의 요구사항을 똑같이 기술하는 이름으로 사용할 수 있습니다.\n이 인터페이스는 여전히 문자열 타입의 label 프로퍼티 하나를 가진다는 것을 의미합니다.\n다른 언어처럼 printLabel에 전달한 객체가 이 인터페이스를 구현해야 한다고 명시적으로 얘기할 필요는 없습니다.\n여기서 중요한 것은 형태뿐입니다. 함수에 전달된 객체가 나열된 요구 조건을 충족하면, 허용됩니다.\n타입 검사는 프로퍼티들의 순서를 요구하지 않습니다. 단지 인터페이스가 요구하는 프로퍼티들이 존재하는지와 프로퍼티들이 요구하는 타입을 가졌는지만을 확인합니다.\n선택적 프로퍼티 (Optional Properties)\n인터페이스의 모든 프로퍼티가 필요한 것은 아닙니다.\n어떤 조건에서만 존재하거나 아예 없을 수도 있습니다.\n선택적 프로퍼티들은 객체 안의 몇 개의 프로퍼티만 채워 함수에 전달하는 \"option bags\" 같은 패턴을 만들 때 유용합니다.\n이 패턴의 예제를 한번 보겠습니다:\ninterface SquareConfig {\n    color?: string;\n    width?: number;\n}\n\nfunction createSquare(config: SquareConfig): {color: string; area: number} {\n    let newSquare = {color: \"white\", area: 100};\n    if (config.color) {\n        newSquare.color = config.color;\n    }\n    if (config.width) {\n        newSquare.area = config.width * config.width;\n    }\n    return newSquare;\n}\n\nlet mySquare = createSquare({color: \"black\"});\n\n선택적 프로퍼티를 가지는 인터페이스는 다른 인터페이스와 비슷하게 작성되고, 선택적 프로퍼티는 선언에서 프로퍼티 이름 끝에 ?를 붙여 표시합니다.\n선택적 프로퍼티의 이점은 인터페이스에 속하지 않는 프로퍼티의 사용을 방지하면서, 사용 가능한 속성을 기술하는 것입니다.\n예를 들어, createSquare안의 color 프로퍼티 이름을 잘못 입력하면, 오류 메시지로 알려줍니다:\ninterface SquareConfig {\n    color?: string;\n    width?: number;\n}\n\nfunction createSquare(config: SquareConfig): { color: string; area: number } {\n    let newSquare = {color: \"white\", area: 100};\n    if (config.clor) {\n        // Error: Property 'clor' does not exist on type 'SquareConfig'\n        newSquare.color = config.clor;\n    }\n    if (config.width) {\n        newSquare.area = config.width * config.width;\n    }\n    return newSquare;\n}\n\nlet mySquare = createSquare({color: \"black\"});\n\n읽기전용 프로퍼티 (Readonly properties)\n일부 프로퍼티들은 객체가 처음 생성될 때만 수정 가능해야합니다.\n프로퍼티 이름 앞에 readonly를 넣어서 이를 지정할 수 있습니다:\ninterface Point {\n    readonly x: number;\n    readonly y: number;\n}\n\n객체 리터럴을 할당하여 Point를 생성합니다.\n할당 후에는 x, y를 수정할 수 없습니다.\nlet p1: Point = { x: 10, y: 20 };\np1.x = 5; // 오류!\n\nTypeScript에서는 모든 변경 메서드(Mutating Methods)가 제거된 Array와 동일한 ReadonlyArray 타입을 제공합니다. 그래서 생성 후에 배열을 변경하지 않음을 보장할 수 있습니다.\nlet a: number[] = [1, 2, 3, 4];\nlet ro: ReadonlyArray = a;\nro[0] = 12; // 오류!\nro.push(5); // 오류!\nro.length = 100; // 오류!\na = ro; // 오류!\n\n예제 마지막 줄에서 ReadonlyArray를 일반 배열에 재할당이 불가능한 것을 확인할 수 있습니다.\n타입 단언(type assertion)으로 오버라이드하는 것은 가능합니다:\na = ro as number[];\n\nreadonly vs const\nreadonly와 const 중에 어떤 것을 사용할 지 기억하기 가장 쉬운 방법은 변수와 프로퍼티중 어디에 사용할지 질문해 보는 것입니다.\n변수는 const를 사용하고 프로퍼티는 readonly를 사용합니다\n초과 프로퍼티 검사 (Excess Property Checks)\n인터페이스의 첫 번째 예제에서 TypeScript가 { label: string; }을 기대해도 { size: number; label: string; }를 허용해주었습니다. 또한 선택적 프로퍼티를 배우고, 소위 \"option bags\"을 기술할 때, 유용하다는 것을 배웠습니다.\n하지만, 그냥 그 둘을 결합하면 에러가 발생할 수 있습니다.\n예를 들어, createSquare를 사용한 마지막 예제를 보겠습니다:\ninterface SquareConfig {\n    color?: string;\n    width?: number;\n}\n\nfunction createSquare(config: SquareConfig): { color: string; area: number } {\n    // ...\n}\n\nlet mySquare = createSquare({ colour: \"red\", width: 100 });\n\ncreateSquare의 매개변수가 color대신 colour로 전달된 것에 유의하세요.\n이 경우 JavaScript에선 조용히 오류가 발생합니다.\nwidth 프로퍼티는 적합하고, color 프로퍼티는 없고, 추가 colour 프로퍼티는 중요하지 않기 때문에, 이 프로그램이 올바르게 작성되었다고 생각할 수 있습니다.\n하지만, TypeScript는 이 코드에 버그가 있을 수 있다고 생각합니다.\n객체 리터럴은 다른 변수에 할당할 때나 인수로 전달할 때, 특별한 처리를 받고, 초과 프로퍼티 검사 (excess property checking)를 받습니다.\n만약 객체 리터럴이 \"대상 타입 (target type)\"이 갖고 있지 않은 프로퍼티를 갖고 있으면, 에러가 발생합니다.\n// error: Object literal may only specify known properties, but 'colour' does not exist in type 'SquareConfig'. Did you mean to write 'color'?\nlet mySquare = createSquare({ colour: \"red\", width: 100 });\n\n이 검사를 피하는 방법은 정말 간단합니다.\n가장 간단한 방법은 타입 단언을 사용하는 것입니다:\nlet mySquare = createSquare({ width: 100, opacity: 0.5 } as SquareConfig);\n\n하지만 특별한 경우에, 추가 프로퍼티가 있음을 확신한다면, 문자열 인덱스 서명(string index signatuer)을 추가하는 것이 더 나은 방법입니다.\n만약 SquareConfig color와 width 프로퍼티를 위와 같은 타입으로 갖고 있고, 또한 다른 프로퍼티를 가질 수 있다면, 다음과 같이 정의할 수 있습니다.\ninterface SquareConfig {\n    color?: string;\n    width?: number;\n    [propName: string]: any;\n}\n\n나중에 인데스 서명에 대해 좀 더 다룰 것입니다. 하지만 여기서는 SquareConfig가 여러 프로퍼티가 가질 수 있고, 그 프로퍼티들이 color나 width가 아니라면, 그들의 타입은 중요하지 않습니다.\n이 검사를 피하는 마지막 방법은 놀랍게도 객체를 다른 변수에 할당하는 것입니다.\nsquareOptions가 추가 프로퍼티 검사를 받지 않기 때문에, 컴파일러는 에러를 주지 않습니다.\nlet squareOptions = { colour: \"red\", width: 100 };\nlet mySquare = createSquare(squareOptions);\n\nsquareOptions와 SquareConfig 사이에 공통 프로퍼티가 있는 경우에만 위와 같은 방법을 사용할 수 있습니다.\n이 예제에서는, width가 그 경우입니다. 하지만 만약에 변수가 공통 객체 프로퍼티가 없으면 에러가 납니다. 예를 들어:\nlet squareOptions = { colour: \"red\" };\nlet mySquare = createSquare(squareOptions);\n\n위처럼 간단한 코드의 경우, 이 검사를 \"피하는\" 방법을 시도하지 않는 것이 좋습니다.\n메서드가 있고 상태를 가지는 등 더 복잡한 객체 리터럴에서 이 방법을 생각해볼 수 있습니다. 하지만 초과 프로퍼티 에러의 대부분은 실제 버그입니다.\n그 말은, 만약 옵션 백 같은 곳에서 초과 프로퍼티 검사 문제가 발생하면, 타입 정의를 수정해야 할 필요가 있습니다.\n예를 들어, 만약 createSquare에 color나 colour 모두 전달해도 괜찮다면, squareConfig가 이를 반영하도록 정의를 수정해야 합니다.\n함수 타입 (Function Types)\n인터페이스는 JavaScript 객체가 가질 수 있는 넓은 범위의 형태를 기술할 수 있습니다.\n프로퍼티로 객체를 기술하는 것 외에, 인터페이스는 함수 타입을 설명할 수 있습니다.\n인터페이스로 함수 타입을 기술하기 위해, 인터페이스에 호출 서명 (call signature)를 전달합니다.\n이는 매개변수 목록과 반환 타입만 주어진 함수 선언과 비슷합니다. 각 매개변수는 이름과 타입이 모두 필요합니다.\ninterface SearchFunc {\n    (source: string, subString: string): boolean;\n}\n\n한번 정의되면, 함수 타입 인터페이스는 다른 인터페이스처럼 사용할 수 있습니다.\n여기서 함수 타입의 변수를 만들고, 같은 타입의 함수 값으로 할당하는 방법을 보여줍니다.\nlet mySearch: SearchFunc;\nmySearch = function(source: string, subString: string) {\n    let result = source.search(subString);\n    return result > -1;\n}\n\n올바른 함수 타입 검사를 위해, 매개변수의 이름이 같을 필요는 없습니다.\n예를 들어, 위의 예제를 아래와 같이 쓸 수 있습니다:\nlet mySearch: SearchFunc;\nmySearch = function(src: string, sub: string): boolean {\n    let result = src.search(sub);\n    return result > -1;\n}\n\n함수 매개변수들은 같은 위치에 대응되는 매개변수끼리 한번에 하나씩 검사합니다.\n만약 타입을 전혀 지정하지 않고 싶다면, SearchFunc 타입의 변수로 직접 함수 값이 할당되었기 때문에 TypeScript의 문맥상 타이핑 (contextual typing)이 인수 타입을 추론할 수 있습니다.\n이 예제에서, 함수 표현의 반환 타입이 반환하는 값으로 추론됩니다. (여기서는 false와 true)\nlet mySearch: SearchFunc;\nmySearch = function(src, sub) {\n    let result = src.search(sub);\n    return result > -1;\n}\n\n함수 표현식이 숫자 나 문자열을 반환했다면, 타입 검사는 반환 타입이 SearchFunc 인터페이스에 정의된 반환 타입과 일치하지 않는다는 에러를 발생시킵니다.\nlet mySearch: SearchFunc;\n\n// error: Type '(src: string, sub: string) => string' is not assignable to type 'SearchFunc'.\n// Type 'string' is not assignable to type 'boolean'.\nmySearch = function(src, sub) {\n  let result = src.search(sub);\n  return \"string\";\n};\n\n인덱서블 타입 (Indexable Types)\n인터페이스로 함수 타입을 설명하는 방법과 유사하게, a[10] 이나 ageMap[\"daniel\"] 처럼 타입을 \"인덱스로\" 기술할 수 있습니다.\n인덱서블 타입은 인덱싱 할때 해당 반환 유형과 함께 객체를 인덱싱하는 데 사용할 수 있는 타입을 기술하는 인덱스 시그니처 (index signature)를 가지고 있습니다.\n예제를 보겠습니다:\ninterface StringArray {\n    [index: number]: string;\n}\n\nlet myArray: StringArray;\nmyArray = [\"Bob\", \"Fred\"];\n\nlet myStr: string = myArray[0];\n\n위에서 인덱스 서명이 있는 StringArray 인터페이스가 있습니다.\n이 인덱스 서명은 StringArray가 number로 색인화(indexed)되면 string을 반환할 것을 나타냅니다.\n인덱스 서명을 지원하는 타입에는 두 가지가 있습니다: 문자열과 숫자.\n두 타입의 인덱서(indexer)를 모두 지원하는 것은 가능하지만, 숫자 인덱서에서 반환된 타입은 반드시 문자열 인덱서에서 반환된 타입의 하위 타입(subtype)이어야 합니다.\n이 이유는 number로 인덱싱 할 때, JavaScript는 실제로 객체를 인덱싱하기 전에 string으로 변환하기 때문입니다.\n즉, 100 (number)로 인덱싱하는 것은 \"100\" (string)로 인덱싱하는 것과 같기 때문에, 서로 일관성 있어야 합니다.\nclass Animal {\n    name: string;\n}\nclass Dog extends Animal {\n    breed: string;\n}\n\n// 오류: 숫자형 문자열로 인덱싱을 하면 완전히 다른 타입의 Animal을 얻게 될 것입니다!\ninterface NotOkay {\n    [x: number]: Animal;\n    [x: string]: Dog;\n}\n\n문자열 인덱스 시그니처는 \"사전\" 패턴을 기술하는데 강력한 방법이지만, 모든 프로퍼티들이 반환 타입과 일치하도록 강제합니다.\n문자열 인덱스가 obj.property가 obj[\"property\"]로도 이용 가능함을 알려주기 때문입니다.\n다음 예제에서, name의 타입은 문자열 인덱스 타입과 일치하지 않고, 타입 검사는 에러를 발생시킵니다.\ninterface NumberDictionary {\n    [index: string]: number;\n    length: number;    // 성공, length는 숫자입니다\n    name: string;      // 오류, `name`의 타입은 인덱서의 하위타입이 아닙니다\n}\n\n하지만, 인덱스 시그니처가 프로퍼티 타입들의 합집합이라면 다른 타입의 프로퍼티들도 허용할 수 있습니다:\ninterface NumberOrStringDictionary {\n    [index: string]: number | string;\n    length: number;    // 성공, length는 숫자입니다\n    name: string;      // 성공, name은 문자열입니다\n}\n\n마지막으로, 인덱스의 할당을 막기 위해 인덱스 시그니처를 읽기 전용으로 만들 수 있습니다:\ninterface ReadonlyStringArray {\n    readonly [index: number]: string;\n}\nlet myArray: ReadonlyStringArray = [\"Alice\", \"Bob\"];\nmyArray[2] = \"Mallory\"; // 오류!\n\n인덱스 시그니처가 읽기 전용이기 때문에 myArray[2]의 값을 할당할 수 없습니다.\n클래스 타입 (Class Types)\n인터페이스 구현하기 (Implementing an interface)\n클래스가 특정 계약(contract)을 충족시키도록 명시적으로 강제하는 C#과 Java와 같은 언어에서 인터페이스를 사용하는 가장 일반적인 방법은 TypeScript에서도 가능합니다.\ninterface ClockInterface {\n    currentTime: Date;\n}\n\nclass Clock implements ClockInterface {\n    currentTime: Date = new Date();\n    constructor(h: number, m: number) { }\n}\n\n아래 예제의 setTime 처럼 클래스에 구현된 메서드를 인터페이스 안에서도 기술할 수 있습니다.\ninterface ClockInterface {\n    currentTime: Date;\n    setTime(d: Date): void;\n}\n\nclass Clock implements ClockInterface {\n    currentTime: Date = new Date();\n    setTime(d: Date) {\n        this.currentTime = d;\n    }\n    constructor(h: number, m: number) { }\n}\n\n인터페이스는 클래스의 public과 private 모두보다는, public을 기술합니다.\n그래서 클래스 인스턴스의 private에서는 특정 타입이 있는지 검사할 수 없습니다.\n클래스의 스태틱과 인스턴스의 차이점 (Difference between the static and instance sides of classes)\n클래스와 인터페이스를 다룰 때, 클래스는 두 가지 타입을 가진다는 것을 기억하는 게 좋습니다: 스태틱 타입과 인스턴스 타입입니다.\n생성 시그니처 (construct signature)로 인터페이스를 생성하고, 클래스를 생성하려고 한다면, 인터페이스를 implements 할 때, 에러가 발생하는 것을 확인할 수 있을 겁니다:\ninterface ClockConstructor {\n    new (hour: number, minute: number);\n}\n\nclass Clock implements ClockConstructor {\n    currentTime: Date;\n    constructor(h: number, m: number) { }\n}\n\n클래스가 인터페이스를 implements 할 때, 클래스의 인스턴스만 검사하기 때문입니다.\n생성자가 스태틱이기 때문에, 이 검사에 포함되지 않습니다.\n대신에, 클래스의 스태틱 부분을 직접적으로 다룰 필요가 있습니다.\n이번 예제에서, ClockConstructor는 생성자를 정의하고, ClockInterface는 인스턴스 메서드를 정의하는 두 인터페이스를 정의합니다.\n그리고, 편의를 위해, 전달된 타입의 인스턴스를 생성하는 createClock 생성자 함수를 정의합니다:\ninterface ClockConstructor {\n    new (hour: number, minute: number): ClockInterface;\n}\ninterface ClockInterface {\n    tick(): void;\n}\n\nfunction createClock(ctor: ClockConstructor, hour: number, minute: number): ClockInterface {\n    return new ctor(hour, minute);\n}\n\nclass DigitalClock implements ClockInterface {\n    constructor(h: number, m: number) { }\n    tick() {\n        console.log(\"beep beep\");\n    }\n}\nclass AnalogClock implements ClockInterface {\n    constructor(h: number, m: number) { }\n    tick() {\n        console.log(\"tick tock\");\n    }\n}\n\nlet digital = createClock(DigitalClock, 12, 17);\nlet analog = createClock(AnalogClock, 7, 32);\n\ncreateClock의 첫 번째 매개변수는 createClock(AnalogClock, 7, 32)안에 ClockConstructor 타입이므로, AnalogClock이 올바른 생성자 시그니처를 갖고 있는지 검사합니다.\n또 다른 쉬운 방법은 클래스 표현을 사용하는 것입니다.\ninterface ClockConstructor {\n  new (hour: number, minute: number);\n}\n\ninterface ClockInterface {\n  tick();\n}\n\nconst Clock: ClockConstructor = class Clock implements ClockInterface {\n  constructor(h: number, m: number) {}\n  tick() {\n      console.log(\"beep beep\");\n  }\n}\n\n인터페이스 확장하기 (Extending Interfaces)\n클래스처럼, 인터페이스들도 확장(extend)이 가능합니다.\n이는 한 인터페이스의 멤버를 다른 인터페이스에 복사하는 것을 가능하게 해주는데, 인터페이스를 재사용성 높은 컴포넌트로 쪼갤 때, 유연함을 제공해줍니다.\ninterface Shape {\n    color: string;\n}\n\ninterface Square extends Shape {\n    sideLength: number;\n}\n\nlet square = {} as Square;\nsquare.color = \"blue\";\nsquare.sideLength = 10;\n\n인터페이스는 여러 인터페이스를 확장할 수 있어, 모든 인터페이스의 조합을 만들어낼 수 있습니다.\ninterface Shape {\n    color: string;\n}\n\ninterface PenStroke {\n    penWidth: number;\n}\n\ninterface Square extends Shape, PenStroke {\n    sideLength: number;\n}\n\nlet square = {} as Square;\nsquare.color = \"blue\";\nsquare.sideLength = 10;\nsquare.penWidth = 5.0;\n\n하이브리드 타입 (Hybrid Types)\n일찍이 언급했듯이, 인터페이스는 실제 JavaScript 세계에 존재하는 다양한 타입들을 기술할 수 있습니다.\nJavaScript의 동적이고 유연한 특성 때문에, 위에서 설명했던 몇몇 타입의 조합으로 동작하는 객체를 가끔 마주할 수 있습니다.\n그러한 예제 중 하나는 추가적인 프로퍼티와 함께, 함수와 객체 역할 모두 수행하는 객체입니다:\ninterface Counter {\n    (start: number): string;\n    interval: number;\n    reset(): void;\n}\n\nfunction getCounter(): Counter {\n    let counter = (function (start: number) { }) as Counter;\n    counter.interval = 123;\n    counter.reset = function () { };\n    return counter;\n}\n\nlet c = getCounter();\nc(10);\nc.reset();\nc.interval = 5.0;\n\n써드파티 (3rd-party) JavaScript와 상호작용할 때, 타입의 형태를 완전히 기술하기 위해 위와 같은 패턴을 사용해야할 수도 있습니다.\n클래스를 확장한 인터페이스 (Interfaces Extending Classes)\n인터페이스 타입이 클래스 타입을 확장하면, 클래스의 멤버는 상속받지만 구현은 상속받지 않습니다.\n이것은 인터페이스가 구현을 제공하지 않고, 클래스의 멤버 모두를 선언한 것과 마찬가지입니다.\n인터페이스는 심지어 기초 클래스의 private과 protected 멤버도 상속받습니다.\n이것은 인터페이스가 private 혹은 protected 멤버를 포함한 클래스를 확장할 수 있다는 뜻이고, 인터페이스 타입은 그 클래스나 하위클래스에 의해서만 구현될 수 있습니다.\n이는 거대한 상속계층을 가지고 있을 때 유용하지만, 특정 프로퍼티를 가진 하위클래스에서만 코드가 동작하도록 지정하는데도 유용합니다.\n하위클래스는 기초클래스에서 상속하는 것 외에는 관련이 있을 필요가 없습니다.\n예를 들어:\nclass Control {\n    private state: any;\n}\n\ninterface SelectableControl extends Control {\n    select(): void;\n}\n\nclass Button extends Control implements SelectableControl {\n    select() { }\n}\n\nclass TextBox extends Control {\n    select() { }\n}\n\n// Error: Property 'state' is missing in type 'Image'.\nclass Image implements SelectableControl {\n    private state: any;\n    select() { }\n}\n\nclass Location {\n\n}\n\n위 예제에서, SelectableControl은 private state 프로퍼티를 포함하여, Control의 모든 멤버를 가지고 있습니다.\nstate는 private 멤버이기 때문에, SelectableControl를 구현하는 것은 Control의 자식에게만 가능합니다.\nControl의 자식만 같은 선언에서 유래된 state private 멤버를 가질수 있기 때문이고, private 멤버들이 호환되기 위해 필요합니다.\nControl 클래스 안에서 SelectableControl의 인스턴스를 통해서 state private 멤버에 접근할 수 있습니다.\nSelectableControl은 select 메서드를 가진 Control과 같은 역할을 합니다.\nButton과 TextBox 클래스들은 SelectableControl의 하위타입이지만 (Control을 상속받고, select 메서드를 가지기 때문에), Image와 Location 클래스는 아닙니다.\n"},"pages/Classes.html":{"url":"pages/Classes.html","title":"클래스","keywords":"","body":"소개 (Introduction)\n기존 JavaScript는 재사용할 수 있는 컴포넌트를 만들기 위해 함수와 프로토타입-기반 상속을 사용했지만, 객체 지향 접근 방식에 익숙한 프로그래머의 입장에서는 클래스가 함수를 상속받고 이런 클래스에서 객체가 만들어지는 것에 다소 어색함을 느낄 수 있습니다.\nECMAScript 6로도 알려진 ECMAScript 2015를 시작으로 JavaScript 프로그래머들은 이런 객체-지향적 클래스-기반의 접근 방식을 사용해서 애플리케이션을 만들 수 있습니다.\nTypeScript에서는 다음 버전의 JavaScript를 기다릴 필요 없이 개발자들이 이러한 기법들을 사용할 수 있게 해주며, 기존의JavaScript로 컴파일하여 주요 브라우저와 플랫폼에서 동작하게 합니다.\n클래스 (Classes)\n간단한 클래스-기반 예제를 살펴보겠습니다:\nclass Greeter {\n    greeting: string;\n    constructor(message: string) {\n        this.greeting = message;\n    }\n    greet() {\n        return \"Hello, \" + this.greeting;\n    }\n}\n\nlet greeter = new Greeter(\"world\");\n\nC# 이나 Java를 사용해봤다면, 익숙한 구문일 것입니다.\n새로운 클래스 Greeter를 선언했습니다. 이 클래스는 3개의 멤버를 가지고 있습니다: greeting 프로퍼티, 생성자 그리고 greet 메서드 입니다.\n클래스 안에서 클래스의 멤버를 참조할 때 this.를 앞에 덧붙이는 것을 알 수 있습니다.\n이것은 멤버에 접근하는 것을 의미합니다.\n마지막 줄에서, new를 사용하여 Greeter클래스의 인스턴스를 생성합니다.\n이 코드는 이전에 정의한 생성자를 호출하여 Greeter 형태의 새로운 객체를 만들고, 생성자를 실행해 초기화합니다.\n상속 (Inheritance)\nTypeScript에서는, 일반적인 객체-지향 패턴을 사용할 수 있습니다.\n클래스-기반 프로그래밍의 가장 기본적인 패턴 중 하나는 상속을 이용하여 이미 존재하는 클래스를 확장해 새로운 클래스를 만들 수 있다는 것입니다.\n예제를 살펴보겠습니다:\nclass Animal {\n    move(distanceInMeters: number = 0) {\n        console.log(`Animal moved ${distanceInMeters}m.`);\n    }\n}\n\nclass Dog extends Animal {\n    bark() {\n        console.log('Woof! Woof!');\n    }\n}\n\nconst dog = new Dog();\ndog.bark();\ndog.move(10);\ndog.bark();\n\n상속 기능을 보여주는 가장 기본적인 예제입니다: 클래스는 기초 클래스로부터 프로퍼티와 메서드를 상속받습니다.\n여기서, Dog은 extends 키워드를 사용하여 Animal이라는 기초 클래스로부터 파생된 파생 클래스입니다.\n파생된 클래스는 하위클래스(subclasses), 기초 클래스는 상위클래스(superclasses) 라고 불리기도 합니다.\nDog는 Animal의 기능을 확장하기 때문에, bark()와 move()를 모두 가진 Dog 인스턴스를 생성할 수 있습니다.\n조금 더 복잡한 예제를 살펴보겠습니다.\nclass Animal {\n    name: string;\n    constructor(theName: string) { this.name = theName; }\n    move(distanceInMeters: number = 0) {\n        console.log(`${this.name} moved ${distanceInMeters}m.`);\n    }\n}\n\nclass Snake extends Animal {\n    constructor(name: string) { super(name); }\n    move(distanceInMeters = 5) {\n        console.log(\"Slithering...\");\n        super.move(distanceInMeters);\n    }\n}\n\nclass Horse extends Animal {\n    constructor(name: string) { super(name); }\n    move(distanceInMeters = 45) {\n        console.log(\"Galloping...\");\n        super.move(distanceInMeters);\n    }\n}\n\nlet sam = new Snake(\"Sammy the Python\");\nlet tom: Animal = new Horse(\"Tommy the Palomino\");\n\nsam.move();\ntom.move(34);\n\n이 예제는 앞에서 언급하지 않은 몇 가지 기능을 다룹니다.\n이번에도 extends 키워드를 사용하여 Animal의 하위클래스를 생성합니다: Horse와 Snake.\n이전 예제와 한 가지 다른 부분은 파생된 클래스의 생성자 함수는 기초 클래스의 생성자를 실행할 super()를 호출해야 한다는 점입니다.\n더욱이 생성자 내에서 this에 있는 프로퍼티에 접근하기 전에 super()를 먼저 호출해야 합니다.\n이 부분은 TypeScript에서 중요한 규칙입니다.\n또한 이 예제는 기초 클래스의 메서드를 하위클래스에 특화된 메서드로 오버라이드하는 방법을 보여줍니다.\n여기서 Snake와 Horse는 Animal의 move를 오버라이드해서 각각 클래스의 특성에 맞게 기능을 가진 move를 생성합니다.\ntom은 Animal로 선언되었지만 Horse의 값을 가지므로 tom.move(34)는 Horse의 오버라이딩 메서드를 호출합니다.\nSlithering...\nSammy the Python moved 5m.\nGalloping...\nTommy the Palomino moved 34m.\n\nPublic, private 그리고 protected 지정자 (Public, private, and protected modifiers)\n기본적으로 공개 (Public by default)\n우리 예제에서는, 프로그램 내에서 선언된 멤버들에 자유롭게 접근할 수 있습니다.\n다른 언어의 클래스가 익숙하다면, 위 예제에서 public을 사용하지 않아도 된다는 점을 알 수 있습니다. 예를 들어, C#에서는 노출 시킬 각 멤버에 public을 붙여야 합니다.\nTypeScript에서는 기본적으로 각 멤버는 public입니다.\n명시적으로 멤버를 public으로 표시할 수도 있습니다.\n이전 섹션의 Animal 클래스를 다음과 같은 방식으로 작성할 수 있습니다:\nclass Animal {\n    public name: string;\n    public constructor(theName: string) { this.name = theName; }\n    public move(distanceInMeters: number) {\n        console.log(`${this.name} moved ${distanceInMeters}m.`);\n    }\n}\n\nECMAScript 비공개 필드 (ECMAScript Private Fields)\nTypeScript 3.8에서, TypeScript는 비공개 필드를 위한 JavaScript의 새로운 문법을 지원합니다:\nclass Animal {\n    #name: string;\n    constructor(theName: string) { this.#name = theName; }\n}\n\nnew Animal(\"Cat\").#name; // 프로퍼티 '#name'은 비공개 식별자이기 때문에 'Animal' 클래스 외부에선 접근할 수 없습니다.\n\n이 문법은 JavaScript 런타임에 내장되어 있으며, 각각의 비공개 필드의 격리를 더 잘 보장할 수 있습니다.\n현재 TypeScript 3.8 릴리즈 노트에 비공개 필드에 대해 자세히 나와있습니다.\nTypeScript의 private 이해하기 (Understanding TypeScript’s private)\nTypeScript에는 멤버를 포함하는 클래스 외부에서 이 멤버에 접근하지 못하도록 멤버를 private으로 표시하는 방법이 있습니다. 예:\nclass Animal {\n    private name: string;\n    constructor(theName: string) { this.name = theName; }\n}\n\nnew Animal(\"Cat\").name; // 오류: 'name'은 비공개로 선언되어 있습니다;\n\nTypeScript는 구조적인 타입 시스템입니다.\n두개의 다른 타입을 비교할 때 어디서 왔는지 상관없이 모든 멤버의 타입이 호환 된다면, 그 타입들 자체가 호환 가능하다고 말합니다.\n그러나 private 및 protected 멤버가 있는 타입들을 비교할 때는 타입을 다르게 처리합니다.\n호환된다고 판단되는 두 개의 타입 중 한 쪽에서 private 멤버를 가지고 있다면, 다른 한 쪽도 무조건 동일한 선언에 private 멤버를 가지고 있어야 합니다.\n이것은 protected 멤버에도 적용됩니다.\n실제로 어떻게 작동하는지 알아보기 위해 다음 예제를 살펴보겠습니다:\nclass Animal {\n    private name: string;\n    constructor(theName: string) { this.name = theName; }\n}\n\nclass Rhino extends Animal {\n    constructor() { super(\"Rhino\"); }\n}\n\nclass Employee {\n    private name: string;\n    constructor(theName: string) { this.name = theName; }\n}\n\nlet animal = new Animal(\"Goat\");\nlet rhino = new Rhino();\nlet employee = new Employee(\"Bob\");\n\nanimal = rhino;\nanimal = employee; // 오류: 'Animal'과 'Employee'은 호환될 수 없음.\n\n이 예제에서는 Animal과 Animal의 하위클래스인 Rhino가 있습니다.\nAnimal과 형태가 같아보이는 Employee라는 새로운 클래스도 있습니다.\n이 클래스들의 인스턴스를 생성하여 할당하고 어떻게 작동하는지 살펴보겠습니다.\nAnimal과 Rhino는 Animal의 private name:string이라는 동일한 선언으로부터 private 부분을 공유하기 때문에 호환이 가능합니다. 하지만 Employee 경우는 그렇지 않습니다.\nEmployee를 Animal에 할당할 때, 타입이 호환되지 않다는 오류가 발생합니다.\nEmployee는 name이라는 private 멤버를 가지고 있지만, Animal에서 선언한 것이 아니기 때문입니다.\nprotected 이해하기 (Understanding protected)\nprotected 지정자도 protected로 선언된 멤버를 파생된 클래스 내에서 접근할 수 있다는 점만 제외하면 private지정자와 매우 유사하게 동작합니다. 예를 들면,\nclass Person {\n    protected name: string;\n    constructor(name: string) { this.name = name; }\n}\n\nclass Employee extends Person {\n    private department: string;\n\n    constructor(name: string, department: string) {\n        super(name);\n        this.department = department;\n    }\n\n    public getElevatorPitch() {\n        return `Hello, my name is ${this.name} and I work in ${this.department}.`;\n    }\n}\n\nlet howard = new Employee(\"Howard\", \"Sales\");\nconsole.log(howard.getElevatorPitch());\nconsole.log(howard.name); // 오류\n\nPerson 외부에서 name을 사용할 수 없지만, Employee는 Person에서 파생되었기 때문에 Employee의 인스턴스 메서드 내에서는 여전히 사용할 수 있습니다.\n생성자 또한 protected로 표시될 수도 있습니다.\n이는 클래스를 포함하는 클래스 외부에서 인스턴스화 할 수 없지만 확장 할 수 있음을 의미합니다. 예를 들면,\nclass Person {\n    protected name: string;\n    protected constructor(theName: string) { this.name = theName; }\n}\n\n// Employee는 Person을 확장할 수 있습니다.\nclass Employee extends Person {\n    private department: string;\n\n    constructor(name: string, department: string) {\n        super(name);\n        this.department = department;\n    }\n\n    public getElevatorPitch() {\n        return `Hello, my name is ${this.name} and I work in ${this.department}.`;\n    }\n}\n\nlet howard = new Employee(\"Howard\", \"Sales\");\nlet john = new Person(\"John\"); // 오류: 'Person'의 생성자는 protected 입니다.\n\n읽기전용 지정자 (Readonly modifier)\nreadonly키워드를 사용하여 프로퍼티를 읽기전용으로 만들 수 있습니다.\n읽기전용 프로퍼티들은 선언 또는 생성자에서 초기화해야 합니다.\nclass Octopus {\n    readonly name: string;\n    readonly numberOfLegs: number = 8;\n    constructor (theName: string) {\n        this.name = theName;\n    }\n}\nlet dad = new Octopus(\"Man with the 8 strong legs\");\ndad.name = \"Man with the 3-piece suit\"; // 오류! name은 읽기전용 입니다.\n\n매개변수 프로퍼티 (Parameter properties)\n마지막 예제의 Octopus 클래스 내에서 name이라는 읽기전용 멤버와 theName이라는 생성자 매개변수를 선언했습니다. 이는 Octopus의 생성자가 수행된 후에 theName의 값에 접근하기 위해서 필요합니다. 매개변수 프로퍼티를 사용하면 한 곳에서 멤버를 만들고 초기화할 수 있습니다. 다음은 매개변수 프로퍼티를 사용한 더 개정된 Octopus클래스입니다.\nclass Octopus {\n    readonly numberOfLegs: number = 8;\n    constructor(readonly name: string) {\n    }\n}\n\n생성자에 짧아진 readonly name: string 파라미터를 사용하여 theName을 제거하고 name 멤버를 생성하고 초기화했습니다. 즉 선언과 할당을 한 곳으로 통합했습니다.\n매개변수 프로퍼티는 접근 지정자나 readonly 또는 둘 모두를 생성자 매개변수에 접두어로 붙여 선언합니다. 매개변수 프로퍼티에 private을 사용하면 비공개 멤버를 선언하고 초기화합니다. 마찬가지로, public, protected, readonly도 동일하게 작용합니다.\n접근자 (Accessors)\nTypeScript는 객체의 멤버에 대한 접근을 가로채는 방식으로 getters/setters를 지원합니다. 이를 통해 각 객체의 멤버에 접근하는 방법을 세밀하게 제어할 수 있습니다.\n간단한 클래스를 get과 set을 사용하도록 변환해봅시다. 먼저 getters와 setters가 없는 예제로 시작합니다.\nclass Employee {\n    fullName: string;\n}\n\nlet employee = new Employee();\nemployee.fullName = \"Bob Smith\";\nif (employee.fullName) {\n    console.log(employee.fullName);\n}\n\n사람들이 임의로 fullName을 직접 설정할 수 있도록 허용하는 것은 매우 편리하지만, 우리는 fullName이 설정될 때 몇 가지 제약 조건이 적용되는 것을 원할 수 있습니다.\n이 버전에서는 백업 데이터베이스 필드의 최대 길이와 호환되는지 확인하기 위해 newName의 길이를 확인하는 setter를 추가합니다. 만약 최대 길이를 초과한다면, 클라이언트 코드에 문제가 있다는 것을 알리기 위해 오류를 발생시킵니다.\n기존의 기능을 유지하기 위해, fullName을 수정하지 않는 간단한 getter도 추가합니다.\nconst fullNameMaxLength = 10;\n\nclass Employee {\n    private _fullName: string;\n\n    get fullName(): string {\n        return this._fullName;\n    }\n\n    set fullName(newName: string) {\n        if (newName && newName.length > fullNameMaxLength) {\n            throw new Error(\"fullName has a max length of \" + fullNameMaxLength);\n        }\n\n        this._fullName = newName;\n    }\n}\n\nlet employee = new Employee();\nemployee.fullName = \"Bob Smith\";\nif (employee.fullName) {\n    console.log(employee.fullName);\n}\n\n접근자가 값의 길이를 확인하고 있는지 검증하기 위해서, 10자가 넘는 이름을 할당하고 오류가 발생함을 확인할 수 있습니다.\n접근자에 대해 주의해야 할 사항:\n먼저 접근자는 ECMAScript 5 이상을 출력하도록 컴파일러를 설정해야 합니다. ECMAScript 3으로의 하향 조정은 지원되지 않습니다. 둘째, get과 set이 없는 접근자는 자동으로 readonly로 유추됩니다. 이는 프로퍼티 내의 사용자들이 변경할 수 없음을 알 수 있기 때문에 코드 내에서 .d.ts 파일을 생성할 때 유용합니다.\n전역 프로퍼티 (Static Properties)\n지금까지는 인스턴스화될 때 객체에 보이는 인스턴스 멤버에 대해서만 살펴보았습니다. 또한 우리는 인스턴스가 아닌 클래스 자체에서 보이는 전역 멤버를 생성할 수 있습니다. 이 예제에서는 모든 grid의 일반적인 값이기 때문에 origin에 static을 사용합니다. 각 인스턴스는 클래스 이름을 앞에 붙여 이 값에 접근할 수 있습니다. 인스턴스 접근 앞에 this.를 붙이는 것과 비슷하게 여기선 전역 접근 앞에 Grid.를 붙입니다.\nclass Grid {\n    static origin = {x: 0, y: 0};\n    calculateDistanceFromOrigin(point: {x: number; y: number;}) {\n        let xDist = (point.x - Grid.origin.x);\n        let yDist = (point.y - Grid.origin.y);\n        return Math.sqrt(xDist * xDist + yDist * yDist) / this.scale;\n    }\n    constructor (public scale: number) { }\n}\n\nlet grid1 = new Grid(1.0);  // 1x scale\nlet grid2 = new Grid(5.0);  // 5x scale\n\nconsole.log(grid1.calculateDistanceFromOrigin({x: 10, y: 10}));\nconsole.log(grid2.calculateDistanceFromOrigin({x: 10, y: 10}));\n\n추상 클래스 (Abstract Classes)\n추상 클래스는 다른 클래스들이 파생될 수 있는 기초 클래스입니다. 추상 클래스는 직접 인스턴스화할 수 없습니다. 추상 클래스는 인터페이스와 달리 멤버에 대한 구현 세부 정보를 포함할 수 있습니다. abstract 키워드는 추상 클래스뿐만 아니라 추상 클래스 내에서 추상 메서드를 정의하는데 사용됩니다.\nabstract class Animal {\n    abstract makeSound(): void;\n    move(): void {\n        console.log(\"roaming the earth...\");\n    }\n}\n\n추상 클래스 내에서 추상으로 표시된 메서드는 구현을 포함하지 않으며 반드시 파생된 클래스에서 구현되어야 합니다. 추상 메서드는 인터페이스 메서드와 비슷한 문법을 공유합니다. 둘 다 메서드 본문을 포함하지 않고 메서드를 정의합니다. 그러나 추상 메서드는 반드시 abstract 키워드를 포함해야 하며, 선택적으로 접근 지정자를 포함할 수 있습니다.\nabstract class Department {\n\n    constructor(public name: string) {\n    }\n\n    printName(): void {\n        console.log(\"Department name: \" + this.name);\n    }\n\n    abstract printMeeting(): void; // 반드시 파생된 클래스에서 구현되어야 합니다.\n}\n\nclass AccountingDepartment extends Department {\n\n    constructor() {\n        super(\"Accounting and Auditing\"); // 파생된 클래스의 생성자는 반드시 super()를 호출해야 합니다.\n    }\n\n    printMeeting(): void {\n        console.log(\"The Accounting Department meets each Monday at 10am.\");\n    }\n\n    generateReports(): void {\n        console.log(\"Generating accounting reports...\");\n    }\n}\n\nlet department: Department; // 추상 타입의 레퍼런스를 생성합니다\ndepartment = new Department(); // 오류: 추상 클래스는 인스턴스화 할 수 없습니다\ndepartment = new AccountingDepartment(); // 추상이 아닌 하위 클래스를 생성하고 할당합니다\ndepartment.printName();\ndepartment.printMeeting();\ndepartment.generateReports(); // 오류: 선언된 추상 타입에 메서드가 존재하지 않습니다\n\n고급 기법 (Advanced Techniques)\n생성자 함수 (Constructor functions)\nTypeScript에서는 클래스를 선언하면 실제로 여러 개의 선언이 동시에 생성됩니다. 첫 번째로 클래스의 인스턴스 타입입니다.\nclass Greeter {\n    greeting: string;\n    constructor(message: string) {\n        this.greeting = message;\n    }\n    greet() {\n        return \"Hello, \" + this.greeting;\n    }\n}\n\nlet greeter: Greeter;\ngreeter = new Greeter(\"world\");\nconsole.log(greeter.greet()); // \"Hello, world\"\"\n\n여기서 let greeter: Greeter라고 할 때, Greeter 클래스의 인스턴스 타입으로 Greeter를 사용합니다. 이것은 거의 다른 객체 지향 언어를 사용하는 프로그래머들에겐 자연스러운 성질입니다.\n또한 생성자 함수라고 불리는 또 다른 값을 생성하고 있습니다. 이것은 클래스의 인스턴스를 new 할 때 호출되는 함수입니다. 실제로 어떻게 보이는지 확인하기 위해 위의 예제에서 만들어진 JavaScript를 살펴보겠습니다.\nlet Greeter = (function () {\n    function Greeter(message) {\n        this.greeting = message;\n    }\n    Greeter.prototype.greet = function () {\n        return \"Hello, \" + this.greeting;\n    };\n    return Greeter;\n})();\n\nlet greeter;\ngreeter = new Greeter(\"world\");\nconsole.log(greeter.greet()); // \"Hello, world\"\n\n여기서, let Greeter는 생성자 함수를 할당받을 것입니다. new를 호출하고 이 함수를 실행할 때, 클래스의 인스턴스를 얻습니다. 또한 생성자 함수는 클래스의 모든 전역 변수들을 포함하고 있습니다. 각 클래스를 생각하는 또 다른 방법은 인스턴스 측면과 정적 측면이 있다는 것 입니다.\n이 차이를 보여주기 위해 예제를 수정해봅시다.\nclass Greeter {\n    static standardGreeting = \"Hello, there\";\n    greeting: string;\n    greet() {\n        if (this.greeting) {\n            return \"Hello, \" + this.greeting;\n        }\n        else {\n            return Greeter.standardGreeting;\n        }\n    }\n}\n\nlet greeter1: Greeter;\ngreeter1 = new Greeter();\nconsole.log(greeter1.greet()); // \"Hello, there\"\n\nlet greeterMaker: typeof Greeter = Greeter;\ngreeterMaker.standardGreeting = \"Hey there!\";\n\nlet greeter2: Greeter = new greeterMaker();\nconsole.log(greeter2.greet()); // \"Hey there!\"\n\n이 예제에서 greeter1은 이전과 비슷하게 작동합니다. Greeter 클래스를 인스턴스화하고 이 객체를 사용합니다. 이것은 전에 본 것입니다.\n다음으로, 클래스를 직접 사용합니다. 여기서 greeterMaker라는 새로운 변수를 생성합니다. 이 변수는 클래스 자체를 유지하거나 생성자 함수를 다르게 설명합니다. 여기서 typeof Greeter를 사용하여 인스턴스 타입이 아닌 \"Greeter 클래스 자체의 타입을 제공합니다\". 혹은 더 정확하게 생성자 함수의 타입인 \"Greeter라는 심볼의 타입을 제공합니다\". 이 타입은 Greeter 클래스의 인스턴스를 만드는 생성자와 함께 Greeter의 모든 정적 멤버를 포함할 것입니다. greeterMaker에 new를 사용함으로써 Greeter의 새로운 인스턴스를 생성하고 이전과 같이 호출합니다.\n인터페이스로써 클래스 사용하기 (Using a class as an interface)\n앞서 언급한 것처럼, 클래스 선언은 클래스의 인스턴스를 나타내는 타입과 생성자 함수라는 두 가지를 생성합니다. 클래스는 타입을 생성하기 때문에 인터페이스를 사용할 수 있는 동일한 위치에서 사용할 수 있습니다.\nclass Point {\n    x: number;\n    y: number;\n}\n\ninterface Point3d extends Point {\n    z: number;\n}\n\nlet point3d: Point3d = {x: 1, y: 2, z: 3};\n\n"},"pages/Functions.html":{"url":"pages/Functions.html","title":"함수","keywords":"","body":"소개 (Introduction)\n함수는 JavaScript로 된 모든 애플리케이션에서의 기본적인 구성 요소입니다.\nJavaScript 함수는 추상화 계층을 구축하거나 클래스 모방, 정보 은닉, 모듈에 대한 방법을 제공합니다.\nTypeScript에는 클래스, 네임스페이스, 모듈이 있지만, 함수는 여전히 이 일을 어떻게 할 것인지를 설명하는 데 있어 핵심 역할을 수행합니다.\nTypeScript에서는 표준 JavaScript 함수가 작업을 수월하게 하도록 몇 가지 새로운 기능을 추가합니다.\n함수 (Function)\nTypeScript 함수는 JavaScript와 마찬가지로 기명 함수(named function)과 익명 함수(anonymous function)로 만들 수 있습니다.\n이를 통해 API에서 함수 목록을 작성하든 일회성 함수를 써서 다른 함수로 전달하든 애플리케이션에 가장 적합한 방법을 선택할 수 있습니다.\nJavaScript에서의 이 두 가지 방법에 대한 예시를 빠르게 다시 보겠습니다:\n// 기명 함수\nfucntion add(x, y) {\n  return x + y;\n}\n\n// 익명 함수\nlet myAdd = function(x, y) { return x + y };\n\nJavaScript에서처럼, 함수는 함수 외부의 변수를 참조할 수 있습니다.\n이런 경우를, 변수를 캡처(capture) 한다고 합니다.\n이것이 어떻게 작동하는지 (그리고 이 기술을 사용할 때의 장단점)를 이해하는 것은 이 본문의 주제를 벗어나는 것이지만, 이 메커니즘이 어떻게 작동하는지에 대한 확실한 이해는 JavaScript 및 TypeScript를 사용하는 데 있어 중요합니다.\nlet z = 100;\n\nfunction addToZ(x, y) {\n  return x + y + z;\n}\n\n함수 타입 (Function Types)\n함수의 타이핑 (Typing the function)\n이전에 사용했던 예시에 타입을 더해보겠습니다.\nfunction add(x: number, y: number): number {\n    return x + y;\n}\n\nlet myAdd = function(x: number, y: number): number { return x + y };\n\n각 파라미터와 함수 자신의 반환될 타입을 정해줄 수 있습니다.\nTypeScript는 반환 문을 보고 반환 타입을 파악할 수 있으므로 반환 타입을 생략할 수 있습니다.\n함수 타입 작성하기 (Writing the function type)\n함수에 타입을 붙였으니, 이제 함수 타입들을 살펴보고 함수의 전체 타입을 작성해 봅시다.\nlet myAdd: (x: number, y: number) => number =\n    function(x: number, y: number): number { return x + y; };\n\n함수의 타입은 매개변수의 타입과 반환 타입이 있습니다.\n전체 함수 타입을 작성하고자 한다면 이 두 가지 타입이 필요합니다.\n매개변수 목록처럼 각 매개변수에 이름과 타입 타입을 작성해 줍시다.\n작성하는 이름은 가독성을 위한 것입니다.\n위의 코드 대신 이렇게 쓸 수도 있습니다:\nlet myAdd: (baseValue: number, increment: number) => number =\n    function(x: number, y: number): number { return x + y; };\n\n매개변수의 타입들이 올바르게 나열되어 있다면 함수 타입에 이름을 붙이더라도 유효한 타입으로 간주합니다.\n두 번째로 반환 타입입니다.\n매개변수 타입들과 반환 타입 사이에 '화살표 표기'( => )를 써서 반환 타입을 분명히 할 수 있습니다.\n이전에 언급했듯이, 함수 표기에 필요한 부분입니다, 그래서 만약 함수가 값을 반환하지 않는다면 비워두는 대신 void를 써서 표시합니다.\n참고로, 매개변수 타입과 반환 타입만이 함수 타입을 구성합니다.\n캡처된 변수는 타입에 반영되지 않습니다.\n사실상 캡처된 변수는 함수의 \"숨겨진 상태\"의 일부이고 API를 구성하지 않습니다.\n타입의 추론 (Inferring the types)\n아래 예시를 직접 입력해보세요. TypeScript 컴파일러가 방정식의 한쪽에만 타입이 있더라도 타입을 알아낼 수 있다는 것을 알아채셨나요?\n// myAdd는 전체 함수 타입을 가집니다\nlet myAdd = function(x: number, y: number): number { return  x + y; };\n\n// 매개변수 x 와 y는 number 타입을 가집니다\nlet myAdd: (baseValue: number, increment: number) => number =\n    function(x, y) { return x + y; };\n\n이러한 타입 추론 형태를 \"contextual typing\" 이라 부릅니다.\n이를 통해 여러분의 프로그램에서 타입을 유지하기 위한 노력을 줄일 수 있습니다.\n선택적 매개변수와 기본 매개변수 (Optional and Default Parameter)\nTypeScript에서는 모든 매개변수가 함수에 필요하다고 가정합니다.\n이것이 null 이나 undefined를 줄 수 없다는 걸 의미하는 것은 아닙니다. 대신 함수가 호출될 때, 컴파일러는 각 매개변수에 대해 사용자가 값을 제공했는지를 검사합니다.\n또한, 컴파일러는 매개변수들이 함수로 전달될 유일한 매개변수라고 가정합니다. 요약하자면, 함수에 주어진 인자의 수는 함수가 기대하는 매개변수의 수와 일치해야 합니다.\nfunction buildName(firstName: string, lastName: string) {\n    return firstName + \" \" + lastName;\n}\n\nlet result1 = buildName(\"Bob\");                  // 오류, 너무 적은 매개변수\nlet result2 = buildName(\"Bob\", \"Adams\", \"Sr.\");  // 오류, 너무 많은 매개변수\nlet result3 = buildName(\"Bob\", \"Adams\");         // 정확함\n\nJavaScript에서는 모든 매개변수가 선택적이고, 사용자는 적합하다고 생각하면 그대로 둘 수 있습니다.\n그렇게 둔다면 그 값은 undefined가 됩니다.\nTypeScript에서도 선택적 매개변수를 원한다면 매개변수 이름 끝에 ? 를 붙임으로써 해결할 수 있습니다.\n그 예시로 성을 선택적 매개변수로 하는 경우를 들어보겠습니다:\nfunction buildName(firstName: string, lastName?: string) {\n    if (lastName)\n        return firstName + \" \" + lastName;\n    else\n        return firstName;\n}\n\nlet result1 = buildName(\"Bob\");                  // 지금은 바르게 동작\nlet result2 = buildName(\"Bob\", \"Adams\", \"Sr.\");  // 오류, 너무 많은 매개변수\nlet result3 = buildName(\"Bob\", \"Adams\");         // 정확함\n\n어느 선택적 매개변수든 반드시 매개변수 정의가 필요합니다.\nlastName 대신 firstName을 선택적으로 하고 싶다면 매개변수의 순서를 변경해야 합니다.\nTypeScript에서는 유저가 값을 제공하지 않거나 undefined로 했을 때에 할당될 매개변수의 값을 정해 놓을 수도 있습니다.\n이것을 기본-초기화 매개변수라고 합니다.\n이전 예시에서 lastName을 \"Smith\" 라고 지정해 보겠습니다.\nfunction buildName(firstName: string, lastName = \"Smith\") {\n    return firstName + \" \" + lastName;\n}\n\nlet result1 = buildName(\"Bob\");                  // 올바르게 동작, \"Bod Smith\" 반환\nlet result2 = buildName(\"Bob\", undefined);       // 여전히 동작, 역시 \"Bob Smith\" 반환\nlet result3 = buildName(\"Bob\", \"Adams\", \"Sr.\");  // 오류, 너무 많은 매개변수\nlet result4 = buildName(\"Bob\", \"Adams\");         // 정확함\n\n모든 필수 매개변수 뒤에 오는 기본-초기화 매개변수는 선택적으로 처리되며, 선택적 매개변수와 마찬가지로 해당 함수를 호출할 때 생략할 수 있습니다.\n이는 선택적 매개변수와 뒤따르는 기본 매개변수의 타입들이 공통성을 공유함을 의미합니다, 그래서 이 두 가지\nfunction buildName(firstName: string, lastName?: string) {\n    // ...\n}\n\n와\nfunction buildName(firstName: string, lastName = \"Smith\") {\n    // ...\n}\n\n는 (firstName: string, lastName?: string) => string 라는 공통된 타입을 공유합니다.\nlastName의 기본값은 타입에서 사라지고 오직 선택적 매개변수라는 사실만 남깁니다.\n순수한 선택적 매개변수와는 다르게 기본-초기화 매개변수는 필수 매개변수 뒤에 오는 것이 강요되지 않습니다.\n만약 기본-초기화 매개변수가 필수 매개변수보다 앞에 오게 된다면 사용자가 명시적으로 undefined 를 전달해 주어야 기본-초기화 매개변수를 볼 수 있습니다.\n앞서 사용했던 예시에 기본 초기화를 firstName에 적용한 것입니다:\nfunction buildName(firstName = \"Will\", lastName: string) {\n    return firstName + \" \" + lastName;\n}\n\nlet result1 = buildName(\"Bob\");                  // 오류, 너무 적은 매개변수\nlet result2 = buildName(\"Bob\", \"Adams\", \"Sr.\");  // 오류, 너무 많은 매개변수\nlet result3 = buildName(\"Bob\", \"Adams\");         // 성공, \"Bob Adams\" 반환\nlet result4 = buildName(undefined, \"Adams\");     // 성공, \"Will Adams\" 반환\n\n나머지 매개변수 (Rest Parameters)\n필수, 선택적, 기본 매개변수는 한 번에 하나의 매개변수만을 가지고 이야기합니다.\n때로는 다수의 매개변수를 그룹 지어 작업하기를 원하거나, 함수가 최종적으로 얼마나 많은 매개변수를 취할지 모를 때도 있을 것입니다.\nJavaScript에서는 모든 함수 내부에 위치한 arguments라는 변수를 사용해 직접 인자를 가지고 작업할 수 있습니다.\nTypeScript에서는 이 인자들을 하나의 변수로 모을 수 있습니다:\nfunction buildName(firstName: string, ...restOfName: string[]) {\n    return firstName + \" \" + restOfName.join(\" \");\n}\n\n// employeeName 은 \"Joseph Samuel Lucas MacKinzie\" 가 될것입니다.\nlet employeeName = buildName(\"Joseph\", \"Samuel\", \"Lucas\", \"MacKinzie\");\n\n나머지 매개변수는 선택적 매개변수들의 수를 무한으로 취급합니다.\n나머지 매개변수로 인자들을 넘겨줄 때는 당신이 원하는 만큼 넘겨 줄 수도 있습니다; 아무것도 넘겨주지 않을 수도 있습니다.\n컴파일러는 생략 부호 (...) 뒤의 이름으로 전달된 인자 배열을 빌드하여 함수에서 사용할 수 있도록 합니다.\n생략 부호는 나머지 매개변수가 있는 함수의 타입에도 사용됩니다:\nfunction buildName(firstName: string, ...restOfName: string[]) {\n    return firstName + \" \" + restOfName.join(\" \");\n}\n\nlet buildNameFun: (fname: string, ...rest: string[]) => string = buildName;\n\nthis\nthis 가 JavaScript에서 어떻게 쓰이는지 아는 것은 일종의 통과의례입니다.\nTypeScript는 JavaScript의 상위 집합이므로 TypeScript 개발자들 역시 this가 어떻게 쓰이는지 또는 this가 잘못 쓰일 때를 발견하는 방법을 배울 필요가 있습니다.\n다행히도 TypeScript는 몇 가지 기술들로 잘못된 this 사용을 잡아낼 수 있습니다.\n만약 JavaScript에서 this가 어떻게 동작하는지 알고 싶다면 먼저 Yehuda Katz의 글 JavaScript 함수 호출과 \"this\" 이해하기 을 읽도록 합니다.\nYehuda의 글은 this의 내부 동작을 아주 잘 설명하므로, 여기서는 기본만 다룰 것입니다.\nthis와 화살표 함수 (this and arrow functions)\nJavaScript에서, this는 함수가 호출될 때 정해지는 변수입니다.\n매우 강력하고 유연한 기능이지만 이것은 항상 함수가 실행되는 콘텍스트에 대해 알아야 한다는 수고가 생깁니다.\n특히 함수를 반환하거나 인자로 넘길 때의 혼란스러움은 악명 높습니다.\n예시를 봅시다:\nlet deck = {\n    suits: [\"hearts\", \"spades\", \"clubs\", \"diamonds\"],\n    cards: Array(52),\n    createCardPicker: function() {\n        return function() {\n            let pickedCard = Math.floor(Math.random() * 52);\n            let pickedSuit = Math.floor(pickedCard / 13);\n\n            return {suit: this.suits[pickedSuit], card: pickedCard % 13};\n        }\n    }\n}\n\nlet cardPicker = deck.createCardPicker();\nlet pickedCard = cardPicker();\n\nalert(\"card: \" + pickedCard.card + \" of \" + pickedCard.suit);\n\ncreateCardPicker가 자기 자신을 반환하는 함수임을 주목해 주세요.\n이 예제를 작동시키면 기대했던 경보 창 대신 오류가 발생할 것입니다.\ncreateCardPicker에 의해 생성된 함수에서 사용 중인 this가 deck 객체가 아닌 window에 설정되었기 때문입니다.\ncardPicker()의 자체적인 호출 때문에 생긴 일입니다.\n최상위 레벨에서의 비-메서드 문법의 호출은 this를 window로 합니다.\n(Note: strict mode에서는 this가 window 대신 undefined 가 됩니다. )\n이 문제는 나중에 사용할 함수를 반환하기 전에 바인딩을 알맞게 하는 것으로 해결할 수 있습니다.\n이 방법대로라면 나중에 사용하는 방법에 상관없이 원본 deck 객체를 계속해서 볼 수 있습니다.\n이를 위해, 함수 표현식을 ES6의 화살표 함수로 바꿀 것입니다.\n화살표 함수는 함수가 호출 된 곳이 아닌 함수가 생성된 쪽의 this를 캡처합니다:\nlet deck = {\n    suits: [\"hearts\", \"spades\", \"clubs\", \"diamonds\"],\n    cards: Array(52),\n    createCardPicker: function() {\n        // NOTE: 아랫줄은 화살표 함수로써, 'this'를 이곳에서 캡처할 수 있도록 합니다\n        return () => {\n            let pickedCard = Math.floor(Math.random() * 52);\n            let pickedSuit = Math.floor(pickedCard / 13);\n\n            return {suit: this.suits[pickedSuit], card: pickedCard % 13};\n        }\n    }\n}\n\nlet cardPicker = deck.createCardPicker();\nlet pickedCard = cardPicker();\n\nalert(\"card: \" + pickedCard.card + \" of \" + pickedCard.suit);\n\n--noImplicitThis 플래그를 컴파일러에 전달하는 실수를 하게 된다면 TypeScript는 경고를 표시할 것입니다.\nthis.suits[pickedSuit] 의 this는 any 타입인 것을 짚고 넘어가겠습니다.\nthis 매개변수 (this parameter)\n불행히도 this.suits[pickedSuit]의 타입은 여전히 any입니다.\nthis가 객체 리터럴 내부의 함수에서 왔기 때문입니다.\n이것을 고치기 위해 명시적으로 this 매개변수를 줄 수 있습니다.\nthis 매개변수는 함수의 매개변수 목록에서 가장 먼저 나오는 가짜 매개변수입니다.\nfunction f(this: void) {\n    // 독립형 함수에서 `this`를 사용할 수 없는 것을 확인함\n}\n\n명확하고 재사용하기 쉽게 Card와 Deck 두 가지 인터페이스 타입들을 예시에 추가해 보겠습니다.\ninterface Card {\n    suit: string;\n    card: number;\n}\ninterface Deck {\n    suits: string[];\n    cards: number[];\n    createCardPicker(this: Deck): () => Card;\n}\nlet deck: Deck = {\n    suits: [\"hearts\", \"spades\", \"clubs\", \"diamonds\"],\n    cards: Array(52),\n    // NOTE: 아래 함수는 이제 callee가 반드시 Deck 타입이어야 함을 명시적으로 지정합니다.\n    createCardPicker: function(this: Deck) {\n        return () => {\n            let pickedCard = Math.floor(Math.random() * 52);\n            let pickedSuit = Math.floor(pickedCard / 13);\n\n            return {suit: this.suits[pickedSuit], card: pickedCard % 13};\n        }\n    }\n}\n\nlet cardPicker = deck.createCardPicker();\nlet pickedCard = cardPicker();\n\nalert(\"card: \" + pickedCard.card + \" of \" + pickedCard.suit);\n\n이제 TypeScript는 createCardPicker가 Deck 객체에서 호출된다는 것을 알게 됐습니다.\n이것은 this가 any 타입이 아니라 Deck 타입이며 따라서 --noImplicitThis 플래그가 어떤 오류도 일으키지 않는다는 것을 의미합니다.\n콜백에서 this 매개변수 (this parameters in callbacks)\n나중에 호출할 콜백 함수를 라이브러리에 전달할 때 this 때문에 오류가 발생할 수 있습니다.\n라이브러리는 콜백을 일반 함수처럼 호출하므로 this는 undefined가 됩니다.\n일부 작업에서는 this 매개변수를 콜백 오류를 막는데 사용할 수 있습니다.\n먼저 라이브러리 작성자는 콜백 타입을 this로 표시를 해주어야 합니다.\ninterface UIElement {\n    addClickListener(onclick: (this: void, e: Event) => void): void;\n}\n\nthis: void는 addClickListener가 onclick이 this타입을 요구하지 않는 함수가 될 것으로 예상하는 것을 의미합니다.\n두 번째로, 호출 코드를 this로 표시합니다.\nclass Handler {\n    info: string;\n    onClickBad(this: Handler, e: Event) {\n        // 이런, `this`가 여기서 쓰이는군요. 이 콜백을 쓰면 런타임에서 충돌을 일으키겠군요\n        this.info = e.message;\n    }\n}\nlet h = new Handler();\nuiElement.addClickListener(h.onClickBad); // 오류!\n\nthis로 표시를 한 상태에서 onClickBad가 반드시 Handler의 인스턴스로써 호출되어야 함을 명시해 주어야 합니다.\n그러면 TypeScript는 addClickListener가 this: void를 갖는 함수를 필요로 한다는 것을 감지합니다.\n오류를 고치기 위해 this의 타입을 바꿔줍니다:\nclass Handler {\n    info: string;\n    onClickGood(this: void, e: Event) {\n        // void 타입이기 때문에 this는 이곳에서 쓸 수 없습니다!\n        console.log('clicked!');\n    }\n}\nlet h = new Handler();\nuiElement.addClickListener(h.onClickGood);\n\nonClickGood이 this 타입을 void로 지정하고 있기 때문에 addClickListener로 넘겨지는데 적합합니다.\n물론, 이것이 this.info를 쓸 수 없는 것을 의미하기도 합니다.\n만약 당신이 this.info까지 원한다면 화살표 함수를 사용해야 할 겁니다:\nclass Handler {\n    info: string;\n    onClickGood = (e: Event) => { this.info = e.message }\n}\n\n이러한 작업은 화살표 함수가 외부의 this를 사용하기 때문에 가능하므로 this: void일 것으로 기대하는 무언가라면 전달에 문제가 없습니다.\nHandler 타입 객체마다 하나의 화살표 함수가 작성된다는 점이 단점입니다.\n반면, 메서드들은 하나만 작성되어 Handler의 프로토타입에 붙습니다.\n그들은 Handler 타입의 모든 객체 간에 공유됩니다.\n오버로드 (Overloads)\nJavaScript는 본질적으로 매우 동적인 언어입니다.\n하나의 JavaScript 함수가 전달된 인자의 형태에 따라 다른 타입의 객체들을 반환하는 것은 흔한 일입니다.\nlet suits = [\"hearts\", \"spades\", \"clubs\", \"diamonds\"];\n\nfunction pickCard(x): any {\n    // 인자가 배열 또는 객체인지 확인\n    // 만약 그렇다면, deck이 주어지고 card를 선택합니다.\n    if (typeof x == \"object\") {\n        let pickedCard = Math.floor(Math.random() * x.length);\n        return pickedCard;\n    }\n    // 그렇지 않다면 그냥 card를 선택합니다.\n    else if (typeof x == \"number\") {\n        let pickedSuit = Math.floor(x / 13);\n        return { suit: suits[pickedSuit], card: x % 13 };\n    }\n}\n\nlet myDeck = [{ suit: \"diamonds\", card: 2 }, { suit: \"spades\", card: 10 }, { suit: \"hearts\", card: 4 }];\nlet pickedCard1 = myDeck[pickCard(myDeck)];\nalert(\"card: \" + pickedCard1.card + \" of \" + pickedCard1.suit);\n\nlet pickedCard2 = pickCard(15);\nalert(\"card: \" + pickedCard2.card + \" of \" + pickedCard2.suit);\n\n여기 사용자가 전달하는 것에 따라 두 가지 다른 결과를 반환하는 함수가 있습니다.\n사용자가 deck을 의미하는 객체 값을 전달한다면 함수가 카드를 선택합니다.\n사용자가 카드를 선택하면 선택한 카드가 무엇인지 대답해 줍니다.\n하지만 타입 시스템에서 이것을 어떻게 구현할 것입니까?\n정답은 오버로드 목록으로 동일한 함수에 다중 함수 타입을 제공하는 것입니다.\n오버로드 목록은 컴파일러가 함수 호출들을 해결할 때 사용하는 것입니다.\n오버로드 목록으로 pickCard가 동작을 승인하고 반환하는 것을 구현해 봅시다:\nlet suits = [\"hearts\", \"spades\", \"clubs\", \"diamonds\"];\n\nfunction pickCard(x: {suit: string; card: number; }[]): number;\nfunction pickCard(x: number): {suit: string; card: number; };\nfunction pickCard(x): any {\n    // 인자가 배열 또는 객체인지 확인\n    // 만약 그렇다면, deck이 주어지고 card를 선택합니다.\n    if (typeof x == \"object\") {\n        let pickedCard = Math.floor(Math.random() * x.length);\n        return pickedCard;\n    }\n    // 그렇지 않다면 그냥 card를 선택합니다.\n    else if (typeof x == \"number\") {\n        let pickedSuit = Math.floor(x / 13);\n        return { suit: suits[pickedSuit], card: x % 13 };\n    }\n}\n\nlet myDeck = [{ suit: \"diamonds\", card: 2 }, { suit: \"spades\", card: 10 }, { suit: \"hearts\", card: 4 }];\nlet pickedCard1 = myDeck[pickCard(myDeck)];\nalert(\"card: \" + pickedCard1.card + \" of \" + pickedCard1.suit);\n\nlet pickedCard2 = pickCard(15);\nalert(\"card: \" + pickedCard2.card + \" of \" + pickedCard2.suit);\n\n이 변화를 통해, 오버로드는 pickCard 함수에 대해 타입 검사 호출을 제공합니다.\n컴파일러가 알맞은 타입 검사를 하기 위해서, JavaScript와 비슷한 프로세스를 따릅니다.\n오버로드 목록에서 첫 번째 오버로드를 진행하면서 제공된 매개변수를 사용하여 함수를 호출하려고 시도합니다.\n만약 일치하게 된다면 해당 오버로드를 알맞은 오버로드로 선택하여 작업을 수행합니다.\n이러한 이유로 가장 구체적인 것부터 오버로드 리스팅을 하는 것이 일반적입니다.\n위 예제에서 function pickCard(x): any는 오버로드 목록에 해당되지 않음을 유의하세요, 그래서 두 가지 오버로드만을 가집니다: 객체를 받는것 하나와 숫자를 받는 것 하나.\n다른 매개변수 타입으로 pickCard를 호출하는 것은 오류가 발생합니다.\n"},"pages/Generics.html":{"url":"pages/Generics.html","title":"제네릭","keywords":"","body":"소개 (Introduction)\n잘 정의되고 일관된 API뿐만 아닌 재사용 가능한 컴포넌트를 구축하는 것도 소프트웨어 엔지니어링에서의 주요한 부분입니다.\n현재의 데이터와 미래의 데이터 모두를 다룰 수 있는 컴포넌트는 거대한 소프트웨어 시스템을 구성하는 데 있어 가장 유연한 능력을 제공할 것입니다.\nC#과 Java 같은 언어에서, 재사용 가능한 컴포넌트를 생성하는 도구상자의 주요 도구 중 하나는 제네릭입니다, 즉, 단일 타입이 아닌 다양한 타입에서 작동하는 컴포넌트를 작성할 수 있습니다.\n사용자는 제네릭을 통해 여러 타입의 컴포넌트나 자신만의 타입을 사용할 수 있습니다.\n제네릭의 Hello World (Hello World of Generics)\n먼저 제네릭의 \"hello world\"인 identity 함수를 해봅시다.\nidentity 함수는 인수로 무엇이 오던 그대로 반환하는 함수입니다.\necho 명령과 비슷하게 생각할 수 있습니다.\n제네릭이 없다면, identity 함수에 특정 타입을 주어야 합니다:\nfunction identity(arg: number): number {\n    return arg;\n}\n\n또는 any 타입을 사용하여 identity 함수를 기술할 수 있습니다:\nfunction identity(arg: any): any {\n    return arg;\n}\n\nany를 쓰는 것은 함수의 arg가 어떤 타입이든 받을 수 있다는 점에서 제네릭이지만, 실제로 함수가 반환할 때 어떤 타입인지에 대한 정보는 잃게 됩니다.\n만약 number 타입을 넘긴다고 해도 any 타입이 반환된다는 정보만 얻을 뿐입니다.\n대신에 우리는 무엇이 반환되는지 표시하기 위해 인수의 타입을 캡처할 방법이 필요합니다.\n여기서는 값이 아닌 타입에 적용되는 타입 변수 를 사용할 것입니다.\nfunction identity(arg: T): T {\n    return arg;\n}\n\nidentity 함수에 T라는 타입 변수를 추가했습니다.\nT는 유저가 준 인수의 타입을 캡처하고 (예 - number), 이 정보를 나중에 사용할 수 있게 합니다.\n여기에서는 T를 반환 타입으로 다시 사용합니다. 인수와 반환 타입이 같은 타입을 사용하고 있는 것을 확인할 수 있습니다.\n이를 통해 타입 정보를 함수의 한쪽에서 다른 한쪽으로 운반할 수 있게끔 합니다.\n이 버전의 identity 함수는 타입을 불문하고 동작하므로 제네릭이라 할 수 있습니다.\nany를 쓰는 것과는 다르게 인수와 반환 타입에 number를 사용한 첫 번째 identity 함수만큼 정확합니다. (즉, 어떤 정보도 잃지 않습니다)\n일단 제네릭 identity 함수를 작성하고 나면, 두 가지 방법 중 하나로 호출할 수 있습니다.\n첫 번째 방법은 함수에 타입 인수를 포함한 모든 인수를 전달하는 방법입니다.\nlet output = identity(\"myString\"); // 출력 타입은 'string'입니다.\n\n여기서 우리는 함수를 호출할 때의 인수 중 하나로써 T를 string으로 명시해 주고 인수 주변에 () 대신 <>로 감싸주었습니다.\n두 번째 방법은 아마 가장 일반적인 방법입니다. 여기서는 타입 인수 추론 을 사용합니다 -- 즉, 우리가 전달하는 인수에 따라서 컴파일러가 T의 값을 자동으로 정하게 하는 것입니다:\nlet output = identity(\"myString\"); //출력 타입은 'string'입니다.\n\n타입 인수를 꺾쇠괄호(<>)에 담아 명시적으로 전달해 주지 않은 것을 주목하세요; 컴파일러는 값인 \"myString\"를 보고 그것의 타입으로 T를 정합니다.\n인수 추론은 코드를 간결하고 가독성 있게 하는 데 있어 유용하지만 더 복잡한 예제에서 컴파일러가 타입을 유추할 수 없는 경우엔 명시적인 타입 인수 전달이 필요할 수도 있습니다.\n제네릭 타입 변수 작업 (Working with Generic Type Variables)\n제네릭을 사용하기 시작하면, identity와 같은 제네릭 함수를 만들 때, 컴파일러가 함수 본문에 제네릭 타입화된 매개변수를 쓰도록 강요합니다.\n즉, 이 매개변수들은 실제로 any 나 모든 타입이 될 수 있는 것처럼 취급할 수 있게 됩니다.\n앞에서 본 identity 함수를 살펴보도록 합니다:\nfunction identity(arg: T): T {\n  return arg;\n}\n\n함수 호출 시마다 인수 arg의 길이를 로그에 찍으려면 어떻게 해야 합니까?\n아마 이것을 쓰고 싶을 겁니다:\nfunction loggingIdentity(arg: T): T {\n  console.log(arg.length); // 오류: T에는 .length 가 없습니다.\n  return arg;\n}\n\n이렇게 하면, 컴파일러는 arg의 멤버 .length를 사용하고 있다는 오류를 낼 것입니다만, 어떤 곳에서도 arg가 이 멤버가 있다는 것이 명시되어 있지 않습니다.\n이전에 이러한 변수 타입은 any나 모든 타입을 의미한다고 했던 것을 기억하십시오. 따라서 이 함수를 쓰고 있는 사용자는 .length 멤버가 없는 number를 대신 전달할 수도 있습니다\n실제로 이 함수가 T가 아닌 T의 배열에서 동작하도록 의도했다고 가정해봅시다. 배열로 사용하기 때문에 .length 멤버는 사용 가능합니다.\n다른 타입들의 배열을 만드는 것처럼 표현할 수 있습니다.\nfunction loggingIdentity(arg: T[]): T[] {\n  console.log(arg.length); // 배열은 .length를 가지고 있습니다. 따라서 오류는 없습니다.\n  return arg;\n}\n\nloggingIdentity의 타입을 \"제너릭 함수 loggingIdentity는 타입 매개변수 T와 T 배열인 인수 arg를 취하고 T 배열을 반환한다.\"라고 읽을 수 있습니다.\n만약 우리가 number 배열을 넘기면 T가 number에 바인딩 되므로 함수는 number 배열을 얻게 됩니다.\n전체 타입변수를 쓰는 것보다 하나의 타입으로써 제네릭 타입변수 T를 사용하는 것은 굉장한 유연함을 제공합니다.\n위 예제를 이렇게도 대체할 수 있습니다.\nfunction loggingIdentity(arg: Array): Array {\n  console.log(arg.length); // 배열은 .length를 가지고 있습니다. 따라서 오류는 없습니다.\n  return arg;\n}\n\n다른 언어들과 비슷한 이런 타입 스타일이 이미 익숙할 것입니다.\n다음 섹션에서는 어떻게 Array와 같은 고유한 제네릭 타입을 만들 수 있는지에 대해 다루도록 하겠습니다.\n제네릭 타입 (Generic Types)\n이전 섹션에서 우리는 타입을 초월한 제네릭 함수 identity를 만들었습니다.\n이번 섹션에서는 함수 자체의 타입과 제네릭 인터페이스를 만드는 방법에 대해 살펴보겠습니다.\n제네릭 함수의 타입은 함수 선언과 유사하게 타입 매개변수가 먼저 나열되는, 비-제네릭 함수의 타입과 비슷합니다.\nfunction identity(arg: T): T {\n  return arg;\n}\n\nlet myIdentity: (arg: T) => T = identity;\n\n또한 타입 변수의 수와 타입 변수가 사용되는 방식에 따라 타입의 제네릭 타입 매개변수에 다른 이름을 사용할 수도 있습니다.\nfunction identity(arg: T): T {\n  return arg;\n}\n\nlet myIdentity: (arg: U) => U = identity;\n\n제네릭 타입을 객체 리터럴 타입의 함수 호출 시그니처로 작성할 수도 있습니다:\nfunction identity(arg: T): T {\n  return arg;\n}\n\nlet myIdentity: { (arg: T): T } = identity;\n\n이것들로 첫 번째 제네릭 인터페이스를 작성할 수 있습니다.\n앞서 예제의 객체 리터럴을 인터페이스로 가져옵니다:\ninterface GenericIdentityFn {\n  (arg: T): T;\n}\n\nfunction identity(arg: T): T {\n  return arg;\n}\n\nlet myIdentity: GenericIdentityFn = identity;\n\n비슷한 예제에서, 제네릭 매개변수를 전체 인터페이스의 매개변수로 옮기고 싶을지도 모릅니다.\n이를 통해 제네릭 타입을 확인할 수 있습니다 (예 -  Dictionary 가 아닌 Dictionary).\n이렇게 하면 인터페이스의 다른 모든 멤버가 타입 매개변수를 볼 수 있습니다.\ninterface GenericIdentityFn {\n  (arg: T): T;\n}\n\nfunction identity(arg: T): T {\n  return arg;\n}\n\nlet myIdentity: GenericIdentityFn = identity;\n\n예제에 아주 작은 변화가 있었습니다.\n제네릭 함수를 작성하는 것 대신 제네릭 타입의 일부인 비-제네릭 함수 시그니처를 가집니다.\nGenericIdentityFn 함수를 사용할 때, 시그니처가 사용할 것을 효과적으로 제한할 특정한 타입 인수가 필요합니다 (여기서는 number).\n타입 매개변수를 호출 시그니처에 바로 넣을 때와 인터페이스 자체에 넣을 때를 이해하는 것은 타입의 제네릭 부분을 설명하는 데 도움이 됩니다.\n제네릭 인터페이스 외에도 제네릭 클래스를 만들 수 있습니다.\n제네릭 열거형과 네임스페이스는 만들 수 없습니다.\n제네릭 클래스 (Generic Classes)\n제네릭 클래스와 제네릭 인터페이스는 형태가 비슷합니다.\n제네릭 클래스는 클래스 이름 뒤에 꺾쇠괄호(<>) 안쪽에 제네릭 타입 매개변수 목록을 가집니다.\nclass GenericNumber {\n    zeroValue: T;\n    add: (x: T, y: T) => T;\n}\n\nlet myGenericNumber = new GenericNumber();\nmyGenericNumber.zeroValue = 0;\nmyGenericNumber.add = function(x, y) { return x + y; };\n\n이것은 GenericNumber 클래스의 문자 그대로 사용하지만 number 타입만 쓰도록 제한하는 것은 없습니다.\n대신 string이나 훨씬 복잡한 객체를 사용할 수 있습니다.\nlet stringNumeric = new GenericNumber();\nstringNumeric.zeroValue = \"\";\nstringNumeric.add = function(x, y) { return x + y; };\n\nconsole.log(stringNumeric.add(stringNumeric.zeroValue, \"test\"));\n\n인터페이스와 마찬가지로 클래스 자체에 타입 매개변수를 넣으면 클래스의 모든 프로퍼티가 동일한 타입으로 동작하는 것을 확인할 수 있습니다.\n클래스에서 다뤘던 것처럼 클래스는 두 가지 타입을 가집니다: 정적 측면과 인스턴스 측면.\n제네릭 클래스는 정적 측면이 아닌 인스턴스 측면에서만 제네릭이므로 클래스로 작업할 때 정적 멤버는 클래스의 타입 매개변수를 쓸 수 없습니다.\n제네릭 제약조건 (Generic Constraints)\n앞쪽의 예제를 기억한다면 특정 타입들로만 동작하는 제네릭 함수를 만들고 싶을 수 있습니다.\n앞서 loggingIdentity 예제에서 arg의 프로퍼티 .length에 접근하기를 원했지만, 컴파일러는 모든 타입에서 .length 프로퍼티를 가짐을 증명할 수 없으므로 경고합니다.\nfunction loggingIdentity(arg: T): T {\n    console.log(arg.length);  // 오류: T에는 .length가 없습니다.\n    return arg;\n}\n\nany와 모든 타입에서 동작하는 대신에, .length 프로퍼티가 있는 any와 모든 타입들에서 작동하는 것으로 제한하고 싶습니다.\n타입이 이 멤버가 있는 한 허용하지만, 최소한 .length 가 있어야 합니다.\n그렇게 하려면 T 가 무엇이 될 수 있는지에 대한 제약 조건을 나열해야 합니다.\n이를 위해 우리의 제약조건이 명시하는 인터페이스를 만듭니다.\n여기 하나의 프로퍼티 .length를 가진 인터페이스를 생성하였고, 우리의 제약사항을 extends 키워드로 표현한 인터페이스를 이용해 명시합니다:\ninterface Lengthwise {\n    length: number;\n}\n\nfunction loggingIdentity(arg: T): T {\n    console.log(arg.length);  // 이제 .length 프로퍼티가 있는 것을 알기 때문에 더 이상 오류가 발생하지 않습니다.\n    return arg;\n}\n\n제네릭 함수는 이제 제한되어 있기 때문에 모든 타입에 대해서는 동작하지 않습니다:\nloggingIdentity(3);  // 오류, number는 .length 프로퍼티가 없습니다.\n\n대신 필요한 프로퍼티들이 있는 타입의 값을 전달해야 합니다:\nloggingIdentity({length: 10, value: 3});\n\n제네릭 제약조건에서 타입 매개변수 사용 (Using Type Parameters in Generic Constraints)\n다른 타입 매개변수로 제한된 타입 매개변수를 선언할 수 있습니다.\n이름이 있는 객체에서 프로퍼티를 가져오고 싶은 경우를 예로 들어 봅시다.\n실수로 obj에 존재하지 않는 프로퍼티를 가져오지 않도록 하기 위해 두 가지 타입에 제약조건을 두었습니다.\nfunction getProperty(obj: T, key: K) {\n    return obj[key];\n}\n\nlet x = { a: 1, b: 2, c: 3, d: 4 };\n\ngetProperty(x, \"a\"); // 성공\ngetProperty(x, \"m\"); // 오류: 인수의 타입 'm' 은 'a' | 'b' | 'c' | 'd'에 해당되지 않음.\n\n제네릭에서 클래스 타입 사용 (Using Class Types in Generics)\n제네릭을 사용하는 TypeScript에서 팩토리를 생성할 때 생성자 함수로 클래스 타입을 참조해야 합니다. 예를 들면:\nfunction create(c: {new(): T; }): T {\n    return new c();\n}\n\n고급 예제에서는 prototype 프로퍼티를 사용하여 생성자 함수와 클래스 타입의 인스턴스 사이의 관계를 유추하고 제한합니다.\nclass BeeKeeper {\n    hasMask: boolean;\n}\n\nclass ZooKeeper {\n    nametag: string;\n}\n\nclass Animal {\n    numLegs: number;\n}\n\nclass Bee extends Animal {\n    keeper: BeeKeeper;\n}\n\nclass Lion extends Animal {\n    keeper: ZooKeeper;\n}\n\nfunction createInstance(c: new () => A): A {\n    return new c();\n}\n\ncreateInstance(Lion).keeper.nametag;  // 타입검사!\ncreateInstance(Bee).keeper.hasMask;   // 타입검사!\n\n"},"pages/Enums.html":{"url":"pages/Enums.html","title":"열거형","keywords":"","body":"열거형 (Enums)\n열거형으로 이름이 있는 상수들의 집합을 정의할 수 있습니다.\n열거형을 사용하면 의도를 문서화 하거나 구분되는 사례 집합을 더 쉽게 만들수 있습니다.\nTypeScript는 숫자와 문자열-기반 열거형을 제공합니다.\n숫자 열거형 (Numeric enums)\n다른 언어를 배워 보신 분들이라면 친숙하게 느끼실 수 있는 숫자 열거형에 대해서 먼저 배워보겠습니다.\n열거형은 enum 키워드를 사용해 정의할 수 있습니다.\nenum Direction {\n    Up = 1,\n    Down,\n    Left,\n    Right,\n}\n\n위 코드에서 Up이 1 로 초기화된 숫자 열거형을 선언했습니다.\n그 지점부터 뒤따르는 멤버들은 자동으로-증가된 값을 갖습니다.\n즉 Direction.Up 은 1,  Down 은 2, Left 는 3, Right 은 4 을 값으로 가집니다.\n원한다면, 전부 초기화 하지 않을 수도 있습니다:\nenum Direction {\n    Up,\n    Down,\n    Left,\n    Right,\n}\n\n위 경우 Up 값은 0,  Down 은 1 이 됩니다.\n자동-증가하는 기능은 멤버 값 자체에는 신경 쓰지 않지만, 각 값이 같은 열거형의 다른 값과 구별돼야 하는 경우에 유용합니다.\n열거형을 사용하는 것은 간단합니다: 그냥 열거형 자체에서 프로퍼티로 모든 멤버에 접근하며, 열거형의 이름을 사용해 타입을 선언합니다.\nenum Response {\n    No = 0,\n    Yes = 1,\n}\n\nfunction respond(recipient: string, message: Response): void {\n    // ...\n}\n\nrespond(\"Princess Caroline\", Response.Yes)\n\n숫자 열거형은 계산된 멤버와 상수 멤버 (아래 참조)를 섞어서 사용할 수 있습니다.\n간단히 말해, 초기화되지 않은 열거형이 먼저 나오거나, 숫자 상수 혹은 다른 상수 열거형 멤버와 함께 초기화된 숫자 열거형 이후에 와야 합니다.\n즉 아래 방식은 허용되지 않습니다:\nenum E {\n    A = getSomeValue(),\n    B, // 오류! 앞에 나온 A가 계산된 멤버이므로 초기화가 필요합니다.\n}\n\n문자열 열거형 (String enums)\n문자열 열거형은 유사한 개념이지만 아래 설명된 것과 같이 런타임에서 열거형의 동작이 약간 다릅니다.\n문자열 열거형에서 각 멤버들은 문자열 리터럴 또는 다른 문자열 열거형의 멤버로 상수 초기화 해야 합니다.\nenum Direction {\n    Up = \"UP\",\n    Down = \"DOWN\",\n    Left = \"LEFT\",\n    Right = \"RIGHT\",\n}\n\n문자열 열거형은 숫자 열거형처럼 자동-증가하는 기능은 없지만, \"직렬화\"를 잘한다는 이점이 있습니다.\n다시 말해서 만약 당신이 숫자 열거형을 이용해서 디버깅하고 있고 그 값을 읽어야 한다면, 종종 그 값이 불확실한 경우가 있습니다 - 숫자만으로는 이것이 어떤 의미인지 유의미한 정보를 제공해주지 않기 때문입니다. (역 매핑 을 이용하면 도움이 될지라도 말입니다), 반면 문자열 열거형을 이용하면 코드를 실행할 때, 열거형 멤버에 지정된 이름과는 무관하게 유의미하고 읽기 좋은 값을 이용하여 실행할 수 있습니다.\n이종 열거형 (Heterogeneous enums)\n기술적으로 열거형은 숫자와 문자를 섞어서 사용할 수 있지만 굳이 그렇게 할 이유는 없습니다.\nenum BooleanLikeHeterogeneousEnum {\n    No = 0,\n    Yes = \"YES\",\n}\n\n확실하게 JavaScript 런타임에서 장점을 취하려는 것이 아니라면, 이렇게 사용하지 않는 것을 권장합니다.\n계산된 멤버와 상수 멤버 (Computed and constant members)\n각 열거형의 멤버는 상수이거나 계산된 값일 수 있습니다.\n열거형의 멤버는 아래의 경우 상수로 간주합니다:\n\n열거형의 첫 번째 데이터이며 초기화 값이 없는 경우, 0으로 값이 할당됩니다.\n// E.X는 상수입니다:\nenum E { X }\n\n\n초기화 값이 없으며 숫자 상수로 초기화된 열거형 멤버 뒤에 따라 나오는 경우.\n앞에 나온 상수 값에 1씩 증가한 값을 상수로 갖습니다.\n// 'E1' 과 'E2' 의 모든 열거형 멤버는 상수입니다.\n\nenum E1 { X, Y, Z }\n\nenum E2 {\n    A = 1, B, C\n}\n\n\n열거형 멤버는 상수 열거형 표현식으로 초기화됩니다.\n상수 열거형 표현식은 컴파일 시 알아낼 수 있는 TypeScript 표현식의 일부입니다.\n아래의 경우 상수 열거형 표현식이라고 합니다:\n\n리터럴 열거형 표현식 (기본적으로 문자 리터럴 또는 숫자 리터럴)\n이전에 정의된 다른 상수 열거형 멤버에 대한 참조 (다른 열거형에서 시작될 수 있음)\n괄호로 묶인 상수 열거형 표현식\n상수 열거형 표현식에 단항 연산자 +, -, ~ 를 사용한 경우\n상수 열거형 표현식을 이중 연산자 +, -, *, /, %, , >>, >>>, &, |, ^ 의 피연산자로 사용할 경우  \n\n상수 열거형 표현식 값이 NaN 이거나 Infinity 이면 컴파일 시점에 오류가 납니다.\n\n\n이외 다른 모든 경우 열거형 멤버는 계산된 것으로 간주합니다.\nenum FileAccess {\n    // 상수 멤버\n    None,\n    Read    = 1 \n유니언 열거형과 열거형 멤버 타입 (Union enums and enum member types)\n계산되지 않는 상수 열거 멤버의 특수한 부분 집합이 있습니다: 리터럴 열거형 멤버\n리터럴 열거형 멤버는 초기화 값이 존재하지 않거나, 아래 값들로 초기화되는 멤버입니다.\n\n문자 리터럴 (예시. \"foo\", \"bar, \"baz\")\n숫자 리터럴 (예시. 1, 100)\n숫자 리터럴에 단항 연산자 - 가 적용된 경우 (e.g. -1, -100)\n\n열거형의 모든 멤버가 리터럴 열거형 값을 가지면 특별한 의미로 쓰이게 됩니다.\n첫째로 열거형 멤버를 타입처럼 사용할 수 있습니다!\n예를 들어 특정 멤버는 오직 열거형 멤버의 값만 가지게 할 수 있습니다.\nenum ShapeKind {\n    Circle,\n    Square,\n}\n\ninterface Circle {\n    kind: ShapeKind.Circle;\n    radius: number;\n}\n\ninterface Square {\n    kind: ShapeKind.Square;\n    sideLength: number;\n}\n\nlet c: Circle = {\n    kind: ShapeKind.Square, // 오류! 'ShapeKind.Circle' 타입에 'ShapeKind.Square' 타입을 할당할 수 없습니다.\n    radius: 100,\n}\n\n또 다른 점은 열거형 타입 자체가 효율적으로 각각의 열거형 멤버의 유니언이 된다는 점입니다.\n아직 유니언 타입에 대해서 배우진 않았지만, 유니언 타입 열거형을 사용하면 타입 시스템이 열거형 자체에 존재하는 정확한 값의 집합을 알고 있다는 사실을 활용할 수 있다는 점만 알아두면 됩니다.\n이 때문에 TypeScript는 값을 잘못 비교하는 어리석은 버그를 잡을 수 있습니다.\n예를 들어:\nenum E {\n    Foo,\n    Bar,\n}\n\nfunction f(x: E) {\n    if (x !== E.Foo || x !== E.Bar) {\n        //             ~~~~~~~~~~~\n        // 에러! E 타입은 Foo, Bar 둘 중 하나이기 때문에 이 조건은 항상 true를 반환합니다.\n    }\n}\n\n이 예제에서 우리는 x 가 E.Foo 가 아닌지 확인합니다.\n만약 이 조건이 true 라면, || 조건은 더는 체크할 필요가 없으므로 if 아래의 body가 실행될 것입니다.\n그러나 만약 이 조건이 통과되지 않는다면, x 는 반드시 E.Foo 이기 때문에, x가 E.Bar 가 아닌지 묻는 조건과 비교하는 것은 적절하지 않습니다.\n런타임에서 열거형 (Enums at runtime)\n열거형은 런타임에 존재하는 실제 객체입니다.\n예를 들어 아래와 같은 열거형은\nenum E {\n    X, Y, Z\n}\n\n실제로 아래와 같이 함수로 전달될 수 있습니다.\nfunction f(obj: { X: number }) {\n    return obj.X;\n}\n\n// E가 X라는 숫자 프로퍼티를 가지고 있기 때문에 동작하는 코드입니다.\nf(E);\n\n컴파일 시점에서 열거형 (Enums at compile time)\n열거형이 런타임에 존재하는 실제 객체라고 할지라도, keyof 키워드는 일반적인 객체에서 기대하는 동작과 다르게 동작합니다. 대신, keyof typeof 를 사용하면 모든 열거형의 키를 문자열로 나타내는 타입을 가져옵니다.\nenum LogLevel {\n    ERROR, WARN, INFO, DEBUG\n}\n\n/**\n * 이것은 아래와 동일합니다. :\n * type LogLevelStrings = 'ERROR' | 'WARN' | 'INFO' | 'DEBUG';\n */\ntype LogLevelStrings = keyof typeof LogLevel;\n\nfunction printImportant(key: LogLevelStrings, message: string) {\n    const num = LogLevel[key];\n    if (num \n역 매핑 (Reverse mappings)\n숫자 열거형 멤버는 멤버의 프로퍼티 이름을 가진 객체를 생성하는 것 외에도 열거형 값에서 열거형 이름으로 역 매핑 을 받습니다.\n예를 들어 아래의 예제에서:\nenum Enum {\n    A\n}\nlet a = Enum.A;\nlet nameOfA = Enum[a]; // \"A\"\n\nTypeScript는 아래와 같은 JavaScript 코드로 컴파일할 겁니다.\nvar Enum;\n(function (Enum) {\n    Enum[Enum[\"A\"] = 0] = \"A\";\n})(Enum || (Enum = {}));\nvar a = Enum.A;\nvar nameOfA = Enum[a]; // \"A\"\n\n이렇게 생성된 코드에서, 열거형은 정방향 (name -> value) 매핑과 역방향 (value -> name) 매핑 두 정보를 모두 저장하는 객체로 컴파일됩니다.\n다른 열거형 멤버 참조는 항상 프로퍼티 접근으로 노출되며 인라인되지 않습니다.\n문자열 열거형은 역 매핑을 생성하지 않는다 는 것을 명심하시길 바랍니다.\nconst 열거형 (const enums)\n대부분의 경우, 열거형은 완벽하게 유효한 해결책입니다.\n하지만 종종 열거형의 요구사항이 좀 더 엄격해 집니다.\n열거형 값에 접근할 때, 추가로 생성된 코드 및 추가적인 간접 참조에 대한 비용을 피하기 위해 const 열거형을 사용할 수 있습니다.\nconst 열거형은 const 지정자를 열거형에 붙여 정의합니다.\nconst enum Enum {\n    A = 1,\n    B = A * 2\n}\n\nconst 열거형은 상수 열거형 표현식만 사용될 수 있으며 일반적인 열거형과 달리 컴파일 과정에서 완전히 제거됩니다.\nconst 열거형은 사용하는 공간에 인라인됩니다.\n이러한 동작은 const 열거형이 계산된 멤버를 가지고 있지 않기 때문에 가능합니다.\nconst enum Directions {\n    Up,\n    Down,\n    Left,\n    Right\n}\n\nlet directions = [Directions.Up, Directions.Down, Directions.Left, Directions.Right]\n\n위 코드는 아래와 같이 컴파일됩니다.\nvar directions = [0 /* Up */, 1 /* Down */, 2 /* Left */, 3 /* Right */];\n\nAmbient 열거형 (Ambient enums)\nAmbient 열거형은 이미 존재하는 열거형 타입의 모습을 묘사하기 위해 사용됩니다.\ndeclare enum Enum {\n    A = 1,\n    B,\n    C = 2\n}\n\nambient 열거형과 비-ambient 열거형의 가장 큰 차이점은, 일반적인 열거형에서 초기화되지 않은 멤버가 상수로 간주하는 멤버 뒤에 있다면, 이 멤버도 상수로 간주할 것입니다.\n반면 (const가 아닌) ambient 열거형에서 초기화되지 않은 멤버는 항상 계산된 멤버로 간주합니다.\n"},"pages/Type Inference.html":{"url":"pages/Type Inference.html","title":"타입 추론","keywords":"","body":"소개 (Introduction)\n이번 장에서는 TypeScript의 타입 추론을 다루겠습니다. 즉 타입이 어디에서, 어떻게 추론되는지 이야기해보겠습니다.\n기본 (Basic)\nTypeScript에서는 타입 표기가 없는 경우 타입 정보를 제공하기 위해 타입을 추론합니다. 예를 들어, 이 코드에서\nlet x = 3;\n\n변수 x 의 타입은 number로 추론됩니다.\n이러한 추론은 변수와 멤버를 초기화하고, 매개변수의 기본값를 설정하며, 함수의 반환 타입을 결정할 때 발생합니다.\n대부분의 경우에 타입 추론은 직관적입니다.\n타입을 추론하는 방법에 대해 좀 더 자세히 알아보겠습니다.  \n최적 공통 타입 (Best common type)\n여러 표현식에서 타입 추론이 발생할 때, 해당 표현식의 타입을 사용하여 \"최적 공통 타입\"을 계산합니다. 예를 들어,\nlet x = [0, 1, null];\n\n위 예제의 x 타입을 추론하려면 각 배열 요소들의 타입을 고려해야 합니다.\n여기서 배열의 타입으로 고를 수 있는 두 가지 후보가 있습니다: number와 null입니다.\n최적 공통 타입 알고리즘은 각 후보 타입을 고려하여 모든 후보 타입을 포함할 수 있는 타입을 선택합니다.\n후보 타입들로부터 최적 공통 타입을 선택하기 때문에, 모든 후보 타입을 포함할 수 있는 상위 타입이 존재해도 후보 타입 중 상위 타입이 존재하지 않으면 선택할 수 없습니다. 예를 들어:\nlet zoo = [new Rhino(), new Elephant(), new Snake()];\n\n이상적으로는 zoo 변수가 Animal[] 타입으로 추론되길 원하지만, 배열 중 Animal 타입의 객체가 없기 때문에 Animal을 배열 요소 타입으로 추론하지 않습니다.\n이를 해결하기 위해서는 모든 후보 타입을 포함하는 상위 타입을 표기해야 합니다.\nlet zoo: Animal[] = [new Rhino(), new Elephant(), new Snake()];\n\n최적 공통 타입이 존재하지 않는 경우, 추론의 결과는 (Rhino | Elephant |  Snake)[]과 같은 유니언 배열 타입입니다.\n문맥상 타이핑 (Contextual Typing)\nTypeScript에서는 경우에 따라 \"다른 방향\"에서도 타입을 추론합니다.\n이를 \"문맥상 타이핑\" 이라고 합니다. 문맥상 타이핑은 표현식의 타입이 해당 위치에 의해 암시될 때 발생합니다. 예를 들면:\nwindow.onmousedown = function(mouseEvent) {\n    console.log(mouseEvent.button);   //\n여기에서 TypeScript 타입 검사는 Window.onmousedown 함수 타입을 사용하여 할당 오른쪽에 함수 표현식의 타입을 추론합니다.\n이렇게 했을 때 mouseEvent 매개변수의 타입이 button 프로퍼티는 있지만, kangaroo 프로퍼티는 없음을 추론할 수 있습니다.\nTypeScript는 다른 문맥에서도 타입 추론을 잘해냅니다.\nwindow.onscroll = function(uiEvent) {\n    console.log(uiEvent.button); //\n위 함수가 Window.onscroll에 할당되어 있다는 사실을 기반으로, TypeScript는 uiEvent가 이전 예제의 MouseEvent가 아닌 UIEvent 임을 알고 있습니다. UIEvent 객체에는 button 프로퍼티가 없어서 TypeScript가 오류를 발생시킵니다.\n만약 이 함수가 문맥적으로 타입이 추론되지 않는 위치에 있다면, 함수의 인수는 암묵적으로 any 타입을 가지며 별도의 오류를 보고하지 않습니다. (--noImplicitAny 옵션을 사용하지 않는다면)\nconst handler = function(uiEvent) {\n    console.log(uiEvent.button); //\n우리는 함수의 인수 타입을 any 타입 표기하여 재정의할 수 있습니다.\nwindow.onscroll = function(uiEvent: any) {\n    console.log(uiEvent.button);  //\n하지만 uiEvent는 button 프로퍼티가 없기 때문에 이 코드는 undefined을 출력합니다.\n문맥상 타이핑은 많은 경우에 적용됩니다.\n일반적인 경우, 함수 호출 인수, 할당의 오른쪽, 타입 단언, 객체 / 배열 리터럴의 멤버, 반환문이 있습니다.\n문맥상 타입은 최적 공통 타입의 후보 타입으로도 사용됩니다. 예를 들어:\nfunction createZoo(): Animal[] {\n    return [new Rhino(), new Elephant(), new Snake()];\n}\n\n이 예제에서 최적 공통 타입은 4가지 후보 타입을 가집니다: Animal, Rhino, Elephant, and Snake.\n이들 중, Animal이 최적 공통 타입 알고리즘에 의해 선택됩니다.\n"},"pages/Type Compatibility.html":{"url":"pages/Type Compatibility.html","title":"타입 호환성","keywords":"","body":"소개 (Introduction)\nTypeScript의 타입 호환성은 구조적 서브 타이핑(subtyping)을 기반으로 합니다.\n구조적 타이핑이란 오직 멤버만으로 타입을 관계시키는 방식입니다.\n명목적 타이핑(nominal typing) 과는 대조적입니다.\n다음 코드를 살펴보겠습니다:\ninterface Named {\n    name: string;\n}\n\nclass Person {\n    name: string;\n}\n\nlet p: Named;\n// 성공, 구조적 타이핑이기 때문입니다.\np = new Person();\n\nC#이나 Java와 같은 명목적-타입 언어에서는 Person 클래스는 Named 인터페이스를 명시적인 구현체로 기술하지 않았기 때문에 해당 코드는 오류를 발생시킵니다.\nTypeScript의 구조적 타입 시스템은 JavaScript 코드의 일반적인 작성 방식에 따라서 설계되었습니다.\nJavaScript는 함수 표현식이나 객체 리터럴 같은 익명 객체를 광범위하게 사용하기 때문에 JavaScript에서 발견되는 관계의 타입을 명목적 타입 시스템보다는 구조적 타입 시스템을 이용하여 표현하는 것이 훨씬 더 자연스럽습니다.\n건전성에 대한 참고사항 (A Note on Soundness)\nTypeScript의 타입 시스템은 컴파일 시간에 확인할 수 없는 특정 작업을 안전하게 수행할 수 있습니다. 타입 시스템이 이런 특성을 갖고 있을 때, \"건전\"하지 않다고 말합니다. TypeScript에서 건전하지 못한 곳을 허용하는 부분을 신중하게 고려했으며, 이 문서 전체에서 이러한 상황이 발생하는 곳과 유발하는 시나리오에 대해 설명합니다.\n시작하기 (Starting out)\nTypeScript의 구조적 타입 시스템의 기본 규칙은 y가 최소한 x와 동일한 멤버를 가지고 있다면 x와 y는 호환된다는 것입니다. 예를 들어:\ninterface Named {\n    name: string;\n}\n\nlet x: Named;\n// y의 추론된 타입은 { name: string; location: string; } 입니다.\nlet y = { name: \"Alice\", location: \"Seattle\" };\nx = y;\n\ny를 x에 할당할 수 있는지 검사하기 위해, 컴파일러는 x의 각 프로퍼티를 검사하여 y에서 상응하는 호환 가능한 프로퍼티를 찾습니다.\n이 경우, y는 name이라는 문자열 멤버를 가지고 있어야 합니다. 그러므로 할당이 허용됩니다.\n함수 호출 인수를 검사할 때 동일한 할당 규칙이 적용됩니다:\nfunction greet(n: Named) {\n    console.log(\"Hello, \" + n.name);\n}\ngreet(y); // 성공\n\ny는 location 프로퍼티를 추가적으로 가지고 있지만 오류를 발생시키지 않는 점에 유의합니다.\n호환성을 검사할 때는 오직 대상 타입의 멤버(이 경우는 Named)만 고려됩니다.\n이 비교하는 과정은 재귀적으로 각 멤버와 하위-멤버의 타입을 탐색하면서 진행됩니다.\n두 함수 비교 (Comparing two functions)\n원시 타입과 객체 타입을 비교하는 것은 비교적 간단하지만, 어떤 유형의 함수들이 호환될 수 있는지에 대한 질문은 조금 더 복잡합니다.\n먼저 매개변수 목록에서만 다른 두 함수의 기본 예제를 살펴보겠습니다:\nlet x = (a: number) => 0;\nlet y = (b: number, s: string) => 0;\n\ny = x; // 성공\nx = y; // 오류\n\nx를 y에 할당할 수 있는지 검사하기 위해, 먼저 매개변수 목록을 살펴봅니다.\nx의 각 매개변수는 호환 가능한 타입을 가진 y의 해당 매개변수를 가져야 합니다.\n매개변수의 이름은 고려하지 않고 타입만 검사한다는 점에 유의하세요.\n이 경우에는 x의 모든 매개변수는 y에 상응하는 호환 가능한 매개변수를 가지므로 할당이 허용됩니다.\n두 번째 할당은 y는 x에 없는 두 번째 필수적인 매개변수를 가지고 있기 때문에 할당이 허용되지 않아 오류가 발생합니다.\ny = x의 예제에서처럼 매개변수를 '버리는' 것이 허용되는 이유가 궁금할 수 있습니다.\n이러한 할당이 허용되는 이유는 함수의 추가 매개변수를 무시하는 것이 실제로 JavaScript에선 매우 일반적이기 때문입니다.\n예를 들어, Array#forEach는 콜백 함수에게 3 가지 매개변수인 배열 요소, 그 요소의 인덱스 그리고 이것을 포함하는 배열을 제공합니다.\n그럼에도 불구하고 첫 번째 매개변수만 사용하는 콜백을 제공하는 것은 매우 유용합니다:\nlet items = [1, 2, 3];\n\n// 추가 매개변수를 강제로 사용하지 마세요.\nitems.forEach((item, index, array) => console.log(item));\n\n// 괜찮습니다!\nitems.forEach(item => console.log(item));\n\n반환 타입이 다른 두 함수를 사용하여 반환 타입이 어떻게 처리되는지 살펴보겠습니다:\nlet x = () => ({name: \"Alice\"});\nlet y = () => ({name: \"Alice\", location: \"Seattle\"});\n\nx = y; // 성공\ny = x; // 오류, x()는 location 프로퍼티가 없습니다.\n\n타입 시스템은 원본 함수의 반환 타입이 대상 타입의 반환 타입의 하위 타입이 되도록 합니다.\n함수 매개변수의 Bivariance (Function Parameter Bivariance)\n함수 매개변수의 타입을 비교할 때, 원본 매개변수가 대상 매개변수에 할당이 가능하거나 이 반대여도 할당은 성공합니다.\n이것은 호출한 측에서 더 특수한 타입을 취하여 함수를 제공할 수도 있지만, 덜 특수화된 타입의 함수를 호출할 수 있기 때문에 바람직하지 않습니다.\n실제로 이런 종류의 오류는 드물지만 이는 많은 일반적인 JavaScript 패턴들을 사용할 수 있게 합니다. 간단한 예제:\nenum EventType { Mouse, Keyboard }\n\ninterface Event { timestamp: number; }\ninterface MouseEvent extends Event { x: number; y: number }\ninterface KeyEvent extends Event { keyCode: number }\n\nfunction listenEvent(eventType: EventType, handler: (n: Event) => void) {\n    /* ... */\n}\n\n// 바람직하진 않지만 유용하고 일반적임\nlistenEvent(EventType.Mouse, (e: MouseEvent) => console.log(e.x + \",\" + e.y));\n\n// 건전성 측면에서 바람직하지 않은 대안\nlistenEvent(EventType.Mouse, (e: Event) => console.log((e as MouseEvent).x + \",\" + (e as MouseEvent).y));\nlistenEvent(EventType.Mouse, ((e: MouseEvent) => console.log(e.x + \",\" + e.y)) as (e: Event) => void);\n\n// 여전히 허용되지 않음 (명확한 오류). 완전히 호환되지 않는 타입에 적용되는 타입 안전성(Type safety)\nlistenEvent(EventType.Mouse, (e: number) => console.log(e));\n\n컴파일러 플래그인 strictFunctionTypes을 통해 이러한 상황이 발생하면 TypeScript에서 오류가 발생하도록 할 수 있습니다.\n선택적 매개변수와 나머지 매개변수 (Optional Parameters and Rest Parameters)\n함수의 호환성을 비교할 때 선택적 매개변수와 필수 매개변수를 서로 바꿔 사용할 수 있습니다.\n원본 타입의 추가 선택적 매개변수는 오류가 아니고, 원본 타입의 해당 매개변수가 없는 대상 타입의 선택적 매개변수도 오류가 아닙니다.\n함수가 나머지 매개변수를 가지고 있다면, 마치 무한한 일련의 선택적 매개변수처럼 처리됩니다.\n이것은 타입 시스템 관점에서는 바람직하지 않지만, 런타임 관점에서는 해당 위치에 undefined를 전달하는 것은 대부분 함수에 해당하므로 선택적 매개변수에 대한 아이디어는 제대로 적용되지 않습니다.\n다음을 유발하는 예제는 콜백을 받아서 (프로그래머에게는) 예측이 가능하지만 (타입 시스템이) 알 수 없는 개수의 인수를 호출하는 함수의 일반적인 패턴입니다:\nfunction invokeLater(args: any[], callback: (...args: any[]) => void) {\n    /* ... 'args'를 사용하여 콜백을 호출함 ... */\n}\n\n// 바람직하지 않음 - invokeLater는 \"아마도\" 여러개의 인수를 제공합니다\ninvokeLater([1, 2], (x, y) => console.log(x + \", \" + y));\n\n// 혼란스럽고 (x와 y가 실제로 필요함) 발견할 수 없음\ninvokeLater([1, 2], (x?, y?) => console.log(x + \", \" + y));\n\n오버로드 함수 (Functions with overloads)\n함수에 오버로드가 있는 경우 원본 타입의 각 오버로드는 대상 타입의 호환 가능한 시그니처와 일치해야 합니다.\n이를 통해 원본 함수와 모든 동일한 상황에서 대상 함수를 호출할 수 있습니다.\n열거형 (Enums)\n열거형은 숫자와 호환되며 숫자는 열거형과 호환됩니다. 다른 열거형 타입의 열거형 값은 호환되지 않는 것으로 간주됩니다. 예를 들면,\nenum Status { Ready, Waiting };\nenum Color { Red, Blue, Green };\n\nlet status = Status.Ready;\nstatus = Color.Green;  // 오류\n\n클래스 (Classes)\n클래스는 객체 리터럴 타입과 인터페이스와 한 가지 예외를 제외하곤 유사하게 동작합니다: 클래스는 정적 타입과 인스턴스 타입이 있습니다.\n클래스 타입의 두 개의 객체를 비교할 때, 오직 인스턴스의 멤버만 비교됩니다.\n정적인 멤버와 생성자는 호환성에 영향을 주지 않습니다.\nclass Animal {\n    feet: number;\n    constructor(name: string, numFeet: number) { }\n}\n\nclass Size {\n    feet: number;\n    constructor(numFeet: number) { }\n}\n\nlet a: Animal;\nlet s: Size;\n\na = s;  // 성공\ns = a;  // 성공\n\n클래스의 private 멤버와 protected 멤버 (Private and protected members in classes)\n클래스의 private과 protected 멤버는 호환성에 영향을 줍니다.\n클래스 인스턴스의 호환성을 검사할 때 대상 타입에 private 멤버가 있다면, 원본 타입 또한 동일 클래스에서 비롯된 private 멤버가 있어야 합니다.\n마찬가지로 protected 멤버가 있는 인스턴스도 똑같이 적용됩니다.\n이를 통해 클래스는 상위 클래스와 호환 가능하지만 같은 형태를 가진 다른 상속 계층 구조의 클래스와는 호환이 되지 않습니다.\n제네릭 (Generics)\nTypeScript는 구조적 타입 시스템이기 때문에, 타입 매개변수는 멤버의 타입의 일부로 사용할 때 결과 타입에만 영향을 줍니다. 에를 들면,\ninterface Empty {\n}\nlet x: Empty;\nlet y: Empty;\n\nx = y;  // 성공, y는 x의 구조와 대응하기 때문\n\n위에서 x와 y는 구조가 타입 인수를 서로 다르게 사용하지 않기 때문에 호환됩니다.\n이 예제에 Empty를 멤버에 추가하여 어떻게 동작하는 살펴봅시다:\ninterface NotEmpty {\n    data: T;\n}\nlet x: NotEmpty;\nlet y: NotEmpty;\n\nx = y;  // 오류, x와 y 는 호환되지 않음\n\n이런 식으로, 타입 인수가 지정된 제네릭 타입은 비-제네릭 타입처럼 동작합니다.\n타입 인수가 지정되지 않은 제네릭 타입에 관해선, 모든 지정되지 않은 타입 인수를 대신해서 any로 지정함으로써 호환성 검사를 합니다.\n그 결과 생성된 타입은 비-제네릭 경우와 마찬가지로 호환성을 검사합니다.\n예를 들어,\nlet identity = function(x: T): T {\n    // ...\n}\n\nlet reverse = function(y: U): U {\n    // ...\n}\n\nidentity = reverse;  // 성공, (x: any) => any는  (y: any) => any와 대응하기 때문\n\n고급 주제 (Advanced Topics)\n하위 타입 vs 할당 (Subtype vs Assignment)\n지금까지 언어 사양에 정의된 용어가 아닌 \"호환\" 을 사용했습니다.\nTypeScript에서는 두 가지 종류의 호환성이 있습니다: 하위 타입과 할당.\n할당은 하위 타입의 호환성을 확장하여 any에서의 할당과 enum과 해당 숫자 값의 할당을 허용하는 규칙을 가진다는 점만 다릅니다.\n언어에서 다른 위치는 상황에 따라 두 가지 호환 메커니즘 중 하나를 사용합니다.\n실용적인 목적을 위해 타입 호환성은 심지어 implements와 extends의 경우에도 할당 호환성에 의해 결정됩니다.\n자세한 내용은 TypeScript 사양을 참고하세요.\n"},"pages/Advanced Types.html":{"url":"pages/Advanced Types.html","title":"고급 타입","keywords":"","body":"목차 (Table of contents)\n교차 타입 (Intersection Types)\n유니언 타입 (Union Types)\n타입 가드와 차별 타입 (Type Guards and Differentiating Types)\n\n사용자-정의 타입 가드 (User-Defined Type Guards)\n타입 서술어 사용하기 (Using type predicates)\nin 연산자 사용하기 (Using the in operator)\n\n\ntypeof 타입 가드 (typeof type guards)\ninstanceof 타입 가드 (instanceof type guards)\n\n널러블 타입 (Nullable types)\n\n선택적 매개변수와 프로퍼티 (Optional parameters and properties)\n타입 가드와 타입 단언 (Type guards and type assertions)\n\n타입 별칭 (Type Aliases)\n\n인터페이스 vs. 타입 별칭 (Interfaces vs. Type Aliases)\n\n문자열 리터럴 타입 (String Literal Types)\n숫자 리터럴 타입 (Numeric Literal Types)\n열거형 멤버 타입 (Enum Member Types)\n판별 유니언\n\n엄격한 검사\n\n다형성 this 타입\n인덱스 타입\n\n인덱스 타입과 인덱스 시그니처\n\n매핑 타입\n\n매핑 타입의 추론\n\n조건부 타입\n\n분산 조건부 타입\n조건부 타입의 타입 추론\n미리 정의된 조건부 타입\n\n교차 타입 (Intersection Types)\n교차 타입은 여러 타입을 하나로 결합합니다.\n기존 타입을 합쳐 필요한 모든 기능을 가진 하나의 타입을 얻을 수 있습니다.\n예를 들어, Person & Serializable & Loggable은 Person 과 Serializable 그리고 Loggable입니다.\n즉, 이 타입의 객체는 세 가지 타입의 모든 멤버를 갖게 됩니다.\n기존 객체-지향 틀과는 맞지 않는 믹스인이나 다른 컨셉들에서 교차 타입이 사용되는 것을 볼 수 있습니다.\n(JavaScript에는 이런 것들이 많습니다!)\n믹스인 만드는 방법을 간단한 예제를 통해 살펴보겠습니다:\nfunction extend(first: First, second: Second): First & Second {\n    const result: Partial = {};\n    for (const prop in first) {\n        if (first.hasOwnProperty(prop)) {\n            (result as First)[prop] = first[prop];\n        }\n    }\n    for (const prop in second) {\n        if (second.hasOwnProperty(prop)) {\n            (result as Second)[prop] = second[prop];\n        }\n    }\n    return result as First & Second;\n}\n\nclass Person {\n    constructor(public name: string) { }\n}\n\ninterface Loggable {\n    log(name: string): void;\n}\n\nclass ConsoleLogger implements Loggable {\n    log(name) {\n        console.log(`Hello, I'm ${name}.`);\n    }\n}\n\nconst jim = extend(new Person('Jim'), ConsoleLogger.prototype);\njim.log(jim.name);\n\n유니언 타입 (Union Types)\n유니언 타입은 교차 타입과 밀접하게 관련되어 있지만, 매우 다르게 사용됩니다.\n가끔, 숫자나 문자열을 매개변수로 기대하는 라이브러리를 사용할 때가 있습니다.\n예를 들어, 다음 함수를 사용할 때입니다:\n/**\n * 문자열을 받고 왼쪽에 \"padding\"을 추가합니다.\n * 만약 'padding'이 문자열이라면, 'padding'은 왼쪽에 더해질 것입니다.\n * 만약 'padding'이 숫자라면, 그 숫자만큼의 공백이 왼쪽에 더해질 것입니다.\n */\nfunction padLeft(value: string, padding: any) {\n    if (typeof padding === \"number\") {\n        return Array(padding + 1).join(\" \") + value;\n    }\n    if (typeof padding === \"string\") {\n        return padding + value;\n    }\n    throw new Error(`Expected string or number, got '${padding}'.`);\n}\n\npadLeft(\"Hello world\", 4); // \"    Hello world\"를 반환합니다.\n\npadLeft의 문제는 매개변수 padding이 any 타입으로 되어있다는 것입니다.\n즉, 숫자나 문자열 둘 다 아닌 인수로 호출할 수 있다는 것이고, TypeScript는 이를 괜찮다고 받아들일 것입니다.\nlet indentedString = padLeft(\"Hello world\", true); // 컴파일 타임에 통과되고, 런타임에 오류.\n\n전통적인 객체지향 코드에서, 타입의 계층을 생성하여 두 타입을 추상화할 수 있습니다.\n이는 더 명시적일 수는 있지만, 좀 과하다고 할 수도 있습니다.\n전통적인 방법의 padLeft에서 좋은 점은 그냥 원시 값을 전달할 수 있다는 것입니다.\n즉 사용법이 간단하고 간결합니다.\n이 새로운 방법은 다른 곳에서 이미 존재하는 함수를 사용하려 할 때, 도움이 되지 않습니다.\nany 대신에, 유니언 타입을 매개변수 padding에 사용할 수 있습니다:\n/**\n * 문자열을 받고 왼쪽에 \"padding\"을 추가합니다.\n * 만약 'padding'이 문자열이라면, 'padding'은 왼쪽에 더해질 것입니다.\n * 만약 'padding'이 숫자라면, 그 숫자만큼의 공백이 왼쪽에 더해질 것입니다.\n */\nfunction padLeft(value: string, padding: string | number) {\n    // ...\n}\n\nlet indentedString = padLeft(\"Hello world\", true); // 컴파일 중에 오류\n\n유니언 타입은 값이 여러 타입 중 하나임을 설명합니다.\n세로 막대 (|)로 각 타입을 구분하여 number | string | boolean은 값의 타입이 number, string 혹은 boolean이 될 수 있음을 나타냅니다.\n유니언 타입을 값으로 가지고 있으면, 유니언에 있는 모든 타입에 공통인 멤버에만 접근할 수 있습니다.\ninterface Bird {\n    fly();\n    layEggs();\n}\n\ninterface Fish {\n    swim();\n    layEggs();\n}\n\nfunction getSmallPet(): Fish | Bird {\n    // ...\n}\n\nlet pet = getSmallPet();\npet.layEggs(); // 성공\npet.swim();    // 오류\n\n유니언 타입은 여기서 약간 까다로울 수 있으나, 익숙해지는데 약간의 직관만 있으면 됩니다.\n만약 값이 A | B 타입을 가지고 있으면, 확신할 수 있는 것은 A 와 B 둘 다 가지고 있는 멤버가 있다는 것뿐입니다.\n이 예제에서, Bird는 fly를 멤버로 가지고 있습니다.\nBird | Fish로 타입이 지정된 변수가 fly 메서드를 가지고 있는지 확신할 수 없습니다\n만약 변수가 실제로 런타임에 Fish이면, pet.fly()를 호출하는 것은 오류입니다.\n타입 가드와 차별 타입 (Type Guards and Differentiating Types)\n유니언 타입은 값의 타입이 겹쳐질 수 있는 상황을 모델링하는데 유용합니다.\nFish가 있는지 구체적으로 알고 싶을 때, 무슨일이 벌어질까요?\nJavaScript에서 가능한 두 값을 구분하는 흔한 방법은 멤버의 존재를 검사하는 것입니다.\n앞에서 말했듯이, 유니언 타입의 모든 구성 성분을 가지고 있다고 보장되는 멤버에만 접근할 수 있습니다.\nlet pet = getSmallPet();\n\n// 이렇게 각 프로퍼티들에 접근하는 것은 오류를 발생시킵니다\nif (pet.swim) {\n    pet.swim();\n}\nelse if (pet.fly) {\n    pet.fly();\n}\n\n같은 코드를 동작하게 하려면, 타입 단언을 사용해야 합니다:\nlet pet = getSmallPet();\n\nif ((pet as Fish).swim) {\n    (pet as Fish).swim();\n} else if ((pet as Bird).fly) {\n    (pet as Bird).fly();\n}\n\n사용자-정의 타입 가드 (User-Defined Type Guards)\n타입 단언을 여러 번 사용한 것을 주목하세요.\n만약 검사를 실시했을 때, 각 브랜치에서 pet의 타입을 알 수 있다면 훨씬 좋을 것입니다.\n마침 TypeScript에는 타입 가드라는 것이 있습니다.\n타입 가드는 스코프 안에서의 타입을 보장하는 런타임 검사를 수행한다는 표현식입니다.\n타입 서술어 사용하기 (Using type predicates)\n타입 가드를 정의하기 위해, 반환 타입이 타입 서술어인 함수를 정의만 하면 됩니다:\nfunction isFish(pet: Fish | Bird): pet is Fish {\n    return (pet as Fish).swim !== undefined;\n}\n\npet is Fish는 이 예제에서의 타입 서술어입니다.\n서술어는 parameterName is Type 형태이고, parameterName는 반드시 현재 함수 시그니처의 매개변수 이름이어야 합니다.\nisFish가 변수와 함께 호출될 때마다, TypeScript는 기존 타입과 호환된다면 그 변수를 특정 타입으로 제한할 것입니다.\n// 이제 'swim'과 'fly'에 대한 모든 호출은 허용됩니다\n\nif (isFish(pet)) {\n    pet.swim();\n}\nelse {\n    pet.fly();\n}\n\nTypeScript가 pet이 if문 안에서 Fish라는 것을 알고 있을뿐만 아니라;\nelse문 안에서 Fish가 없다는 것을 알고 있으므로, Bird를 반드시 가지고 있어야합니다.\nin 연산자 사용하기 (Using the in operator)\nin 연산자는 타입을 좁히는 표현으로 작용합니다.\nn in x 표현에서, n은 문자열 리터럴 혹은 문자열 리터럴 타입이고 x는 유니언 타입입니다. \"true\" 분기에서는 선택적 혹은 필수 프로퍼티 n을 가지는 타입으로 좁히고, \"false\" 분기에서는 선택적 혹은 누락된 프로퍼티 n을 가지는 타입으로 좁혀집니다.\nfunction move(pet: Fish | Bird) {\n    if (\"swim\" in pet) {\n        return pet.swim();\n    }\n    return pet.fly();\n}\n\ntypeof 타입 가드 (typeof type guards)\n다시 돌아와서 유니언 타입을 사용하는 버전의 padLeft 코드를 작성해보겠습니다.\n다음과 같이 타입 서술어를 사용해서 작성할 수 있습니다:\nfunction isNumber(x: any): x is number {\n    return typeof x === \"number\";\n}\n\nfunction isString(x: any): x is string {\n    return typeof x === \"string\";\n}\n\nfunction padLeft(value: string, padding: string | number) {\n    if (isNumber(padding)) {\n        return Array(padding + 1).join(\" \") + value;\n    }\n    if (isString(padding)) {\n        return padding + value;\n    }\n    throw new Error(`Expected string or number, got '${padding}'.`);\n}\n\n그러나 타입이 원시 값인지 확인하는 함수를 정의하는 것은 너무나 귀찮습니다.\n운 좋게도, TypeScript는 typeof를 타입 가드로 인식하기 때문에 typeof x === \"number\"를 함수로 추상할 필요가 없습니다.\n즉 타입 검사를 인라인으로 작성할 수 있습니다.\nfunction padLeft(value: string, padding: string | number) {\n    if (typeof padding === \"number\") {\n        return Array(padding + 1).join(\" \") + value;\n    }\n    if (typeof padding === \"string\") {\n        return padding + value;\n    }\n    throw new Error(`Expected string or number, got '${padding}'.`);\n}\n\ntypeof 타입 가드는 두 가지 다른 형식인 typeof v === \"typename\" 와 typeof v !== \"typename\"이 있습니다. 여기서 typename은 \"number\", \"string\", \"boolean\" 그리고 \"symbol\"이여야 합니다.\nTypeScript에서 위에 없는 다른 문자열과 비교하는 것을 막지는 않지만, 타입 가드의 표현식으로 인지되지 않습니다.\ninstanceof 타입 가드 (instanceof type guards)\n위의 typeof 타입 가드를 읽었고 JavaScript의 instanceof 연산자에 익숙하다면 이미 알고 있을 것입니다.\ninstanceof 타입 가드 는 생성자 함수를 사용하여 타입을 좁히는 방법입니다.\n위의 string-padder 예제를 다시 보겠습니다:\ninterface Padder {\n    getPaddingString(): string\n}\n\nclass SpaceRepeatingPadder implements Padder {\n    constructor(private numSpaces: number) { }\n    getPaddingString() {\n        return Array(this.numSpaces + 1).join(\" \");\n    }\n}\n\nclass StringPadder implements Padder {\n    constructor(private value: string) { }\n    getPaddingString() {\n        return this.value;\n    }\n}\n\nfunction getRandomPadder() {\n    return Math.random() \ninstanceof의 오른쪽은 생성자 함수여야 하며, TypeScript는 다음과 같이 좁힙니다:\n\n함수의 prototype 프로퍼티 타입이 any가 아닌 경우\n타입의 생성자 시그니처에서 반환된 유니언 타입일 경우\n\n위와 같은 순서대로 진행됩니다.\n널러블 타입 (Nullable types)\nTypeScript는 각각 값이 null과 undefined를 갖는 특수한 타입인 null과 undefined가 있습니다.\n기본 타입에서 짧게 언급한 바 있습니다.\n기본적으로, 타입 검사 시 null과 undefined를 아무것에나 할당할 수 있다고 간주합니다.\n실제로 null과 undefined는 모든 타입에서 유효한 값입니다.\n즉, 방지하고 싶어도 어떤 타입에 할당되는 것을 방지할 없습니다.\nnull의 개발자인 Tony Hoare는 이를 두고\"십억 불짜리 실수 (billion dollar mistake)\"라고 부릅니다.\n이건 --strictNullChecks 플래그로 해결합니다: 변수를 선언할 때, 자동으로 null이나 undefined를 포함하지 않습니다.\n유니언 타입을 사용하여 명시적으로 포함할 수 있습니다.\nlet s = \"foo\";\ns = null; // 오류, 'null'은 'string'에 할당할 수 없습니다\nlet sn: string | null = \"bar\";\nsn = null; // 성공\n\nsn = undefined; // 오류, 'undefined'는 'string | null'에 할당할 수 없습니다.\n\nTypeScript는 JavaScript와 맞추기 위해 null과 undefined를 다르게 처리합니다.\nstring | null은 string | undefined와 string | undefined | null과는 다른 타입입니다.\nTypeScript 3.7 이후부터는 널러블 타입을 간단하게 다룰 수 있게 optional chaining를 사용할 수 있습니다.\n선택적 매개변수와 프로퍼티 (Optional parameters and properties)\n--strictNullChecks를 적용하면, 선택적 매개변수가 | undefined를 자동으로 추가합니다:\nfunction f(x: number, y?: number) {\n    return x + (y || 0);\n}\nf(1, 2);\nf(1);\nf(1, undefined);\nf(1, null); // 오류, 'null'은 'number | undefined'에 할당할 수 없습니다\n\n선택적 프로퍼티도 마찬가지입니다:\nclass C {\n    a: number;\n    b?: number;\n}\nlet c = new C();\nc.a = 12;\nc.a = undefined; // 오류, 'undefined'는 'number'에 할당할 수 없습니다\nc.b = 13;\nc.b = undefined; // 성공\nc.b = null; // 오류, 'null'은 'number | undefined'에 할당할 수 없습니다.\n\n타입 가드와 타입 단언 (Type guards and type assertions)\n널러블 타입이 유니언으로 구현되기 때문에, null을 제거하기 위해 타입 가드를 사용할 필요가 있습니다\n다행히, JavaScript에서 작성했던 코드와 동일합니다.\nfunction f(sn: string | null): string {\n    if (sn == null) {\n        return \"default\";\n    }\n    else {\n        return sn;\n    }\n}\n\n여기서 null은 확실하게 제거되어 보이지만, 간단한 연산자를 사용할 수도 있습니다:\nfunction f(sn: string | null): string {\n    return sn || \"default\";\n}\n\n컴파일러가 null이나 undefined를 제거할 수 없는 경우, 타입 단언 연산자를 사용하여 수동으로 제거할 수 있습니다.\n구문은 !를 후위 표기하는 방법입니다: identifier!는 null과 undefined를 identifier의 타입에서 제거합니다.\nfunction broken(name: string | null): string {\n  function postfix(epithet: string) {\n    return name.charAt(0) + '.  the ' + epithet; // 오류, 'name'은 아마도 null 입니다\n  }\n  name = name || \"Bob\";\n  return postfix(\"great\");\n}\n\nfunction fixed(name: string | null): string {\n  function postfix(epithet: string) {\n    return name!.charAt(0) + '.  the ' + epithet; // 성공\n  }\n  name = name || \"Bob\";\n  return postfix(\"great\");\n}\n\n예제는 중첩 함수를 사용합니다. 왜냐하면 컴파일러가 중첩 함수안에서는 null을 제거할 수 없기 때문입니다 (즉시-호출된 함수 표현은 예외).\n특히 외부 함수에서 호출될 경우, 중첩 함수에 대한 모든 호출을 추적할 수 없기 때문입니다.\n함수가 어디에서 호출되었는지 알 수 없으면, 본문이 실행될 때 name의 타입을 알 수 없습니다.\n타입 별칭 (Type Aliases)\n타입 별칭은 타입의 새로운 이름을 만듭니다.\n타입 별칭은 때때로 인터페이스와 유사합니다만, 원시 값, 유니언, 튜플 그리고 손으로 작성해야 하는 다른 타입의 이름을 지을 수 있습니다.\ntype Name = string;\ntype NameResolver = () => string;\ntype NameOrResolver = Name | NameResolver;\nfunction getName(n: NameOrResolver): Name {\n    if (typeof n === \"string\") {\n        return n;\n    }\n    else {\n        return n();\n    }\n}\n\n별칭은 실제로 새로운 타입을 만드는 것은 아닙니다 - 그 타입을 나타내는 새로운 이름 을 만드는 것입니다.\n원시 값의 별칭을 짓는 것은 문서화의 형태로 사용할 수 있지만, 별로 유용하지 않습니다.\n인터페이스처럼, 타입 별칭은 제네릭이 될 수 있습니다 - 타입 매개변수를 추가하고 별칭 선언의 오른쪽에 사용하면 됩니다:\ntype Container = { value: T };\n\n프로퍼티 안에서 자기 자신을 참조하는 타입 별칭을 가질 수 있습니다:\ntype Tree = {\n    value: T;\n    left: Tree;\n    right: Tree;\n}\n\n교차 타입과 같이 사용하면, 아주 놀라운 타입을 만들 수 있습니다.\ntype LinkedList = T & { next: LinkedList };\n\ninterface Person {\n    name: string;\n}\n\nvar people: LinkedList;\nvar s = people.name;\nvar s = people.next.name;\nvar s = people.next.next.name;\nvar s = people.next.next.next.name;\n\n하지만, 타입 별칭을 선언의 오른쪽 이외에 사용하는 것은 불가능합니다.\ntype Yikes = Array; // 오류\n\n인터페이스 vs. 타입 별칭 (Interfaces vs. Type Aliases)\n위에서 언급했듯이, 타입 별칭은 인터페이스와 같은 역할을 할 수 있습니다; 하지만, 약간의 미묘한 차이가 있습니다\n한 가지 차이점은 인터페이스는 어디에서나 사용할 수 있는 새로운 이름을 만들 수 있습니다.\n타입 별칭은 새로운 이름을 만들지 못합니다 — 예를 들어, 오류 메시지는 별칭 이름을 사용하지 않습니다.\n아래의 코드에서, 에디터에서 interfaced에 마우스를 올리면  Interface를 반환한다고 보여주지만 aliased는 객체 리터럴 타입을 반환한다고 보여줍니다.\ntype Alias = { num: number }\ninterface Interface {\n    num: number;\n}\ndeclare function aliased(arg: Alias): Alias;\ndeclare function interfaced(arg: Interface): Interface;\n\nTypeScript의 이전 버전에서, 타입 별칭은 extend 하거나 implement 할 수 없었습니다 (다른 타입을 extend/implement 할 수도 없습니다). 2.7 버전부터, 타입 별칭은 교차 타입을 생성함으로써 extend 할 수 있습니다. 예를 들어, type Cat = Animal & { purrs: true }.\n소프트웨어의 이상적인 특징은 확장에 개방되어 있기 때문에, 가능하면 항상 타입 별칭보다 인터페이스를 사용해야 합니다.\n반면에, 만약 인터페이스로 어떤 형태를 표현할 수 없고 유니언이나 튜플 타입을 사용해야 한다면, 일반적으로 타입 별칭을 사용합니다.\n문자열 리터럴 타입 (String Literal Types)\n문자열 리터럴 타입은 문자열에 값을 정확하게 지정할 수 있게 해줍니다.\n예제에서 문자열 리터럴 타입은 유니언 타입, 타입 가드, 그리고 타입 별칭과 잘 결합됩니다.\n이 기능을 열거형-같은 행동을 문자열과 함께 사용할 수 있습니다.\ntype Easing = \"ease-in\" | \"ease-out\" | \"ease-in-out\";\nclass UIElement {\n    animate(dx: number, dy: number, easing: Easing) {\n        if (easing === \"ease-in\") {\n            // ...\n        }\n        else if (easing === \"ease-out\") {\n        }\n        else if (easing === \"ease-in-out\") {\n        }\n        else {\n            // 오류! null이나 undefined를 전달하면 안됩니다\n        }\n    }\n}\n\nlet button = new UIElement();\nbutton.animate(0, 0, \"ease-in\");\nbutton.animate(0, 0, \"uneasy\"); // 오류: \"uneasy\"는 여기서 허용하지 않습니다\n\n허용되는 3개의 문자열 아무거나 전달할 수 있지만, 그 외 다른 문자열들은 오류를 발생시킵니다.\nArgument of type '\"uneasy\"' is not assignable to parameter of type '\"ease-in\" | \"ease-out\" | \"ease-in-out\"'\n\n문자열 리터럴 타입은 오버로드를 구별하기 위해 같은 방법으로 사용할 수 있습니다.\nfunction createElement(tagName: \"img\"): HTMLImageElement;\nfunction createElement(tagName: \"input\"): HTMLInputElement;\n// ... 더 많은 오버로드 ...\nfunction createElement(tagName: string): Element {\n    // ... 이곳에 코드를 ...\n}\n\n숫자 리터럴 타입 (Numeric Literal Types)\nTypeScript는 또한 숫자 리터럴 타입을 갖고 있습니다.\nfunction rollDice(): 1 | 2 | 3 | 4 | 5 | 6 {\n    // ...\n}\n\n명시적으로 작성되는 경우는 거의 없지만, 이슈를 좁히고 버그를 잡는데 유용할 수 있습니다.\nfunction foo(x: number) {\n    if (x !== 1 || x !== 2) {\n        //         ~~~~~~~\n        // '!==' 연산자는 '1'과 '2' 타입에 적용할 수 없습니다.\n    }\n}\n\n다시 말하면, x는 2와 비교될 때, 반드시 1이어야 하는데 위의 검사가 유효하지 않은 비교를 의미합니다.\n열거형 멤버 타입 (Enum Member Types)\n열거형 섹션에서 언급했듯이, 열거형 멤버는 모든 멤버가 리터럴로-초기화될 때 타입을 가집니다.\n싱글톤 타입을 이야기 할때 여기서는 열거형 멤버 타입과 숫자/문자열 리터럴 타입을 얘기하지만, 대부분 많은 유저들은 \"싱글톤 타입\"과 \"리터럴 타입\"을 상호 교환적으로 사용합니다.\n판별 유니언 (Discriminated Unions)\n태그 된 유니언 또는 대수적 데이터 타입이라고도 하는 판별 유니언 고급 패턴을 만들기 위해서 싱글톤 타입, 유니언 타입, 타입 가드, 타입 별칭을 합칠 수 있습니다.\n판별 유니언은 함수형 프로그래밍에서 유용합니다.\n어떤 언어에서는 자동으로 판별 유니언을 제공합니다; TypeScript는 대신에 현재 JavaScript 패턴을 기반으로 합니다.\n세 가지 요소가 있습니다:\n\n공통 싱글톤 타입 프로퍼티를 갖는 타입 — 판별식.\n해당 타입들의 유니언을 갖는 타입 별칭 — 유니언.\n공통 프로퍼티의 타입 가드\n\ninterface Square {\n    kind: \"square\";\n    size: number;\n}\ninterface Rectangle {\n    kind: \"rectangle\";\n    width: number;\n    height: number;\n}\ninterface Circle {\n    kind: \"circle\";\n    radius: number;\n}\n\n먼저 통합할 인터페이스를 선언합니다.\n각 인터페이스는 다른 문자열 리터럴 타입의 kind 프로퍼티를 가집니다.\nkind 프로퍼티는 판별식 혹은 태그라고 부릅니다.\n다른 프로퍼티는 각 인터페이스에 따라 다릅니다.\n현재 인터페이스는 관련이 없다는 것에 유의하세요.\n이제 유니언으로 집어넣어 봅시다:\ntype Shape = Square | Rectangle | Circle;\n\n이제 판별 유니언을 사용해보겠습니다:\nfunction area(s: Shape) {\n    switch (s.kind) {\n        case \"square\": return s.size * s.size;\n        case \"rectangle\": return s.height * s.width;\n        case \"circle\": return Math.PI * s.radius ** 2;\n    }\n}\n\n엄격한 검사 (Exhaustiveness checking)\n판별 유니언의 모든 변형을 커버할 수 없을 때, 컴파일러가 알려주길 원합니다.\n예를 들어, 만약 Triangle을 Shape에 추가하면, area도 업데이트해야 합니다.\ntype Shape = Square | Rectangle | Circle | Triangle;\nfunction area(s: Shape) {\n    switch (s.kind) {\n        case \"square\": return s.size * s.size;\n        case \"rectangle\": return s.height * s.width;\n        case \"circle\": return Math.PI * s.radius ** 2;\n    }\n    // 여기서 오류 발생 - \"triangle\"의 케이스를 처리하지 않음\n}\n\n이를 해결하기 위해 두 가지 방법이 있습니다.\n첫 번째는 --strictNullChecks를 키고 반환 타입을 지정하는 것입니다.\nfunction area(s: Shape): number { // 오류: number | undefined를 반환합니다\n    switch (s.kind) {\n        case \"square\": return s.size * s.size;\n        case \"rectangle\": return s.height * s.width;\n        case \"circle\": return Math.PI * s.radius ** 2;\n    }\n}\n\nswitch가 더 이상 철저하지 않아서 TypeScript는 함수가 undefined를 반환할 수 있다는 것을 알고 있습니다.\n만약 명시적인 반환 타입 number를 가지고 있으면, 반환 타입이 실제로 number | undefined라는 오류를 얻게 됩니다.\n하지만 이 방법은 꽤 애매하고 --strictNullChecks가 예전 코드에서 항상 작동하는 것은 아닙니다.\n두 번째 방법은 컴파일러가 완전함을 검사하기 위해 사용하는 never 타입을 사용하는 것입니다.\nfunction assertNever(x: never): never {\n    throw new Error(\"Unexpected object: \" + x);\n}\nfunction area(s: Shape) {\n    switch (s.kind) {\n        case \"square\": return s.size * s.size;\n        case \"rectangle\": return s.height * s.width;\n        case \"circle\": return Math.PI * s.radius ** 2;\n        default: return assertNever(s); // 빠진 케이스가 있다면 여기서 오류 발생\n    }\n}\n\n여기서, assertNever는 s가 never 타입인지 검사합니다 — 모든 다른 케이스들이 제거된 후 남은 타입.\n만약 케이스를 잊었다면, s는 실제 타입을 가질 것이고 타입 오류가 발생합니다.\n이 방법은 추가 함수를 정의해야 합니다만 잊어버렸을 때, 훨씬 더 명백해집니다.\n다형성 this 타입 (Polymorphic this types)\n다형성 this 타입은 포함하는 클래스나 인터페이스의 하위 타입을 나타냅니다.\nF-bounded polymorphism이라고 부릅니다.\n예를 들어, 계층적으로 유연한 인터페이스를 표현하기 더 쉽게 만듭니다.\n각 연산 후에 this를 반환하는 간단한 계산기를 보겠습니다:\nclass BasicCalculator {\n    public constructor(protected value: number = 0) { }\n    public currentValue(): number {\n        return this.value;\n    }\n    public add(operand: number): this {\n        this.value += operand;\n        return this;\n    }\n    public multiply(operand: number): this {\n        this.value *= operand;\n        return this;\n    }\n    // ... 다른 연산들은 여기에 작성 ...\n}\n\nlet v = new BasicCalculator(2)\n            .multiply(5)\n            .add(1)\n            .currentValue();\n\n클래스가 this 타입을 사용하기 때문에, 이를 extend 할 수 있고 새로운 클래스가 아무 변경 없이 이전 메서드를 사용할 수 있습니다.\nclass ScientificCalculator extends BasicCalculator {\n    public constructor(value = 0) {\n        super(value);\n    }\n    public sin() {\n        this.value = Math.sin(this.value);\n        return this;\n    }\n    // ... 다른 연산들은 여기에 작성 ...\n}\n\nlet v = new ScientificCalculator(2)\n        .multiply(5)\n        .sin()\n        .add(1)\n        .currentValue();\n\nthis 타입 없이, ScientificCalculator는 BasicCalculator를 extend 할 수 없을 것이고 유연한 인터페이스를 유지하지 못할 것입니다.\nmultiply는 sin 메서드를 가지지 않는 BasicCalculator를 반환합니다.\n하지만, this 타입으로, multiply는 this를 반환하고, 여기서는 ScientificCalculator을 말합니다.\n인덱스 타입 (Index types)\n인덱스 타입을 사용하면, 동적인 프로퍼티 이름을 사용하는 코드를 컴파일러가 검사할 수 있습니다.\n예를 들어, 일반적인 JavaScript 패턴은 객체에서 프로퍼티의 부분집합을 뽑아내는 것입니다:\nfunction pluck(o, propertyNames) {\n    return propertyNames.map(n => o[n]);\n}\n\n여기서는 인덱스 타입 쿼리와 인덱스 접근 연산자를 사용해서 TypeScript에서 이 함수를 어떻게 작성하고 사용하는지 보여줍니다:\nfunction pluck(o: T, propertyNames: K[]): T[K][] {\n  return propertyNames.map(n => o[n]);\n}\n\ninterface Car {\n    manufacturer: string;\n    model: string;\n    year: number;\n}\nlet taxi: Car = {\n    manufacturer: 'Toyota',\n    model: 'Camry',\n    year: 2014\n};\n\n// Manufacturer과 model은 둘 다 문자열 타입입니다,\n// 그래서 둘 다 타이핑된 문자열 배열로 끌어낼 수 있습니다.\nlet makeAndModel: string[] = pluck(taxi, ['manufacturer', 'model']);\n\n// 만약 model과 year를 끌어내려고 하면,\n// 유니언 타입의 배열: (string | number)[] 을 얻게됩니다.\nlet modelYear = pluck(taxi, ['model', 'year'])\n\n컴파일러는 manufacturer 와 model이 실제 Car의 프로퍼티인지 검사합니다.\n예제는 몇 가지 새로운 타입 연산자를 소개합니다.\n첫 번째, keyof T는 인덱스 타입 쿼리 연산자입니다.\nany 타입인 T, keyof T는 T의 알려지고 공개된 프로퍼티 이름들의 유니언입니다.\n예를 들어:\nlet carProps: keyof Car; // ('manufacturer' | 'model' | 'year')의 유니언\n\nkeyof Car는 'manufacturer' | 'model' | 'year'와 완전히 호환됩니다.\n차이점은 Car에 ownersAddress: string라는 또 다른 프로퍼티를 추가한다면, keyof Car는 자동으로 'manufacturer' | 'model' | 'year' | 'ownersAddress'로 업데이트합니다.\n그리고 미리 프로퍼티 이름을 알 수 없을 때, pluck처럼 제네릭 컨텍스트에서 keyof를 사용할 수 있습니다.\n즉 컴파일러가 올바른 프로퍼티 이름들의 집합을 pluck에 전달하는지 검사합니다:\n// 오류, 'manufacturer' | 'model' | 'year'에 'unknown'이 없습니다.\npluck(taxi, ['year', 'unknown']); /\n\n두 번째 연산자는 인덱스 접근 연산자 T[K]입니다.\n여기서, 타입 구문은 표현 구문을 반영합니다.\n즉 person['name']은 Person['name'] 타입 — 이 예제에서는 단지 string, 을 가집니다.\n하지만, 인덱스 타입 쿼리처럼, T[K]를 제네릭 컨텍스트에서 사용할 수 있습니다.\n타입 변수 K extends keyof T인지 확인하면 됩니다.\n여기 getProperty 함수의 또 다른 예제가 있습니다.\nfunction getProperty(o: T, propertyName: K): T[K] {\n    return o[propertyName]; // o[propertyName]는 T[K] 타입입니다\n}\n\ngetProperty, o: T 그리고 propertyName: K은 o[propertyName]: T[K]를 의미합니다.\nT[K] 결과를 반환하면, 컴파일러는 실제 키의 타입을 인스턴스화하고, getProperty의 반환 타입은 요청한 프로퍼티에 따라 달라집니다.\nlet name: string = getProperty(taxi, 'manufacturer');\nlet year: number = getProperty(taxi, 'year');\n\n// 오류, 'unknown'은 'manufacturer' | 'model' | 'year'에 없습니다\nlet unknown = getProperty(taxi, 'unknown');\n\n인덱스 타입과 인덱스 시그니처 (Index types and index signatures)\nkeyof와 T[K]가 인덱스 시그니처와 상호 작용합니다. 인덱스 시그니처 매개변수 타입은 'string' 혹은 'number'이어야 합니다.\n만약 문자열 인덱스 시그니처인 타입이 있으면, keyof T는 string | number가 될 것입니다\n(그냥 string이 아닙니다, JavaScript에선 문자열 (object['42'])나 숫자 (object[42])를 사용해서\n객체 프로퍼티에 접근할 수 있습니다).\n그리고 T[string]은 인덱스 시그니처의 타입입니다:\ninterface Dictionary {\n    [key: string]: T;\n}\nlet keys: keyof Dictionary; // string | number\nlet value: Dictionary['foo']; // number\n\n숫자 인덱스 시그니처인 타입이 있으면, keyof T는 number일 것입니다.\ninterface Dictionary {\n    [key: number]: T;\n}\nlet keys: keyof Dictionary; // 숫자\nlet value: Dictionary['foo']; // 오류, 프로퍼티 'foo'는 타입 'Dictionary'에 존재하지 않습니다.\nlet value: Dictionary[42]; // 숫자\n\n매핑 타입 (Mapped types)\n기존 타입을 가져와 선택적 프로퍼티로 만드는 것은 일반적인 작업입니다:\ninterface PersonPartial {\n    name?: string;\n    age?: number;\n}\n\n혹은 읽기전용 버전을 원할 수도 있습니다:\ninterface PersonReadonly {\n    readonly name: string;\n    readonly age: number;\n}\n\nJavaScript에서 충분히 자주 일어나는 일이며 TypeScript는 이전 타입 — 매핑 타입을 기반으로 새로운 타입을 만드는 방법을 제공합니다.\n매핑 타입에서, 새로운 타입은 이전 타입에서 각 프로퍼티를 같은 방법으로 변환합니다.\n예를 들어, 모든 프로퍼티를 readonly 혹은 선택적으로 만들수 있습니다.\n여기 몇가지 예제가 있습니다:\ntype Readonly = {\n    readonly [P in keyof T]: T[P];\n}\ntype Partial = {\n    [P in keyof T]?: T[P];\n}\n\n그리고 사용하기 위해서는:\ntype PersonPartial = Partial;\ntype ReadonlyPerson = Readonly;\n\n이 구문이 멤버보다는 타입을 설명한다는 것에 유의하세요.\n멤버를 추가하길 원한다면, 교차 타입을 사용할 수 있습니다:\n// Use this:\ntype PartialWithNewMember = {\n  [P in keyof T]?: T[P];\n} & { newMember: boolean }\n\n// 다음을 사용하지 **마세요**!\n// 오류입니다!\ntype PartialWithNewMember = {\n  [P in keyof T]?: T[P];\n  newMember: boolean;\n}\n\n가장 간단한 매핑 타입과 그 부분을 봅시다:\ntype Keys = 'option1' | 'option2';\ntype Flags = { [K in Keys]: boolean };\n\n구문은 for .. in이 들어간 인덱스 시그니처 구문과 유사합니다.\n세 부분으로 나뉩니다:\n\n각 프로퍼티에 순서대로 바인딩되는 타입 변수 K.\n반복할 프로퍼티 이름이 포함된 문자열 리터럴 유니언 Keys.\n프로퍼티의 결과 타입\n\n이 간단한 예제에서, Keys는 하드-코딩된 프로퍼티 이름 목록이고 프로퍼티 타입은 항상 boolean입니다, 그래서 이 매핑 타입은 아래 쓰인 것과 동일합니다:\ntype Flags = {\n    option1: boolean;\n    option2: boolean;\n}\n\n하지만 실제 애플리케이션은, 위에서 readonly나 Partial처럼 보입니다.\n존재하는 타입을 기반으로 하고, 특정 방법으로 프로퍼티를 변형시킵니다.\n이때 keyof와 인덱스 접근 타입이 등장합니다:\ntype NullablePerson = { [P in keyof Person]: Person[P] | null }\ntype PartialPerson = { [P in keyof Person]?: Person[P] }\n\n하지만 일반적인 버전을 가지는 게 더 유용할 것입니다.\ntype Nullable = { [P in keyof T]: T[P] | null }\ntype Partial = { [P in keyof T]?: T[P] }\n\n이 예제들에서, 프로퍼티 목록은 keyof T이고 결과 타입은 T[P]의 변형입니다.\n이는 매핑 타입의 일반적인 사용에 있어 좋은 템플릿입니다.\n왜냐하면 이런 종류의 변형이 동형 (homomorphic) 이기 때문에, 매핑이 T의 프로퍼티에만 적용되고 다른 것에는 적용되지 않습니다.\n컴파일러는 새로운 것을 추가하기 전에 존재하는 모든 프로퍼티 지정자를 복사할 수 있다는 것을 알고 있습니다.\n예를 들어, 만약 Person.name이 읽기 전용이었다면, Partial.name은 읽기 전용이고 선택적일 것입니다.\nProxy 클래스 안에 래핑 된 T[P]에 대한 예제가 하나 더 있습니다.\ntype Proxy = {\n    get(): T;\n    set(value: T): void;\n}\ntype Proxify = {\n    [P in keyof T]: Proxy;\n}\nfunction proxify(o: T): Proxify {\n   // ... 프록시 래핑 ...\n}\nlet proxyProps = proxify(props);\n\nReadonly와 Partial가 아주 유용하다는 것을 주목하세요, 이들은 Pick과 Record와 함께 TypeScript의 표준 라이브러리에 포함되어 있습니다.\ntype Pick = {\n    [P in K]: T[P];\n}\ntype Record = {\n    [P in K]: T;\n}\n\nReadonly, Partial 그리고 Pick은 동형이지만 Record는 아닙니다.\nRecord가 동형이 아니라는 단서 중 하나는 프로퍼티를 복사하는 입력 타입을 받지 않는 것입니다:\ntype ThreeStringProps = Record\n\n비-동형 타입은 본질적으로 새로운 프로퍼티를 만듭니다, 그래서 어디서든지 프로퍼티 지정자를 복사할 수 없습니다.\n매핑 타입의 추론 (Inference from mapped types)\n타입의 프로퍼티를 어떻게 래핑 하는지 알게 되었으니, 다음에 하고 싶은 것은 어떻게 언래핑(unwrap) 할지입니다.\n다행히, 꽤 쉽습니다:\nfunction unproxify(t: Proxify): T {\n    let result = {} as T;\n    for (const k in t) {\n        result[k] = t[k].get();\n    }\n    return result;\n}\n\nlet originalProps = unproxify(proxyProps);\n\n이 언래핑 추론은 동형 매핑된 타입에만 동작합니다.\n만약 매핑 타입이 동형이 아니면 언래핑 함수에 명시적인 타입 매개변수를 주어야 할 것입니다.\n조건부 타입 (Conditional Types)\nTypeScript 2.8에서 비-균등 타입 매핑을 표현하는 기능을 추가하는 조건부 타입을 도입했습니다.\n조건부 타입은 타입 관계 검사로 표현된 조건에 따라 두 가지 가능한 타입 중 하나를 선택합니다:\nT extends U ? X : Y\n\n위의 타입은 T가 U에 할당될 수 있으면 타입은 X가 되고 그렇지 않다면 타입이 Y가 된다는 것을 뜻합니다.\n조건부 타입 T extends U ? X : Y는 X 나 Y로 결정되거나, 지연됩니다, 왜냐하면 조건이 하나 혹은 그 이상의 타입 변수에 의존하기 때문입니다.\nT나 U가 타입 변수를 포함할 때, X 또는 Y로 결정되거나 지연될지, 타입 시스템이 T가 항상 U에 할당할 수 있는지에 대해 충분한 정보를 가지고 있는지 여부로 결정됩니다.\n즉시 결정되는 일부 타입의 예제로, 다음 예제를 살펴보겠습니다:\ndeclare function f(x: T): T extends true ? string : number;\n\n// 타입은 'string | number'\nlet x = f(Math.random() \n또 다른 예제는 중첩 조건부 타입을 사용하는 TypeName 타입 별칭입니다:\ntype TypeName =\n    T extends string ? \"string\" :\n    T extends number ? \"number\" :\n    T extends boolean ? \"boolean\" :\n    T extends undefined ? \"undefined\" :\n    T extends Function ? \"function\" :\n    \"object\";\n\ntype T0 = TypeName;  // \"string\"\ntype T1 = TypeName;  // \"string\"\ntype T2 = TypeName;  // \"boolean\"\ntype T3 = TypeName void>;  // \"function\"\ntype T4 = TypeName;  // \"object\"\n\n하지만 조건부 타입이 지연되는 지점 - 분기를 선택하기보단 고정되는 - 의 예를 들면 다음과 같습니다:\ninterface Foo {\n    propA: boolean;\n    propB: boolean;\n}\n\ndeclare function f(x: T): T extends Foo ? string : number;\n\nfunction foo(x: U) {\n    // 'U extends Foo ? string : number' 타입을 가지고 있습니다\n    let a = f(x);\n\n    // 이 할당은 허용됩니다!\n    let b: string | number = a;\n}\n\n위에서, 변수 a는 아직 분기를 선택하지 못한 조건부 타입을 가지고 있습니다.\n또 다른 코드가 foo의 호출을 그만두면, U를 다른 타입으로 대체할 것이고, TypeScript가 실제로 분기를 선택할 수 있는지 결정하기 위해 조건부 타입을 재-평가할 것입니다.\n그동안, 조건부 타입을 조건부의 각 분기가 대상에 할당 가능한 한 다른 대상 타입으로 할당할 수 있습니다.\n그래서 위 예제에서 조건부가 어떻게 평가되든지, string혹은 number로 알려져 있기 때문에, 조건이 U extends Foo ? string : numer를 string | number로 할당할 수 있었습니다.\n분산 조건부 타입 (Distributive conditional types)\n검사된 타입이 벗겨진 (naked) 타입 매개변수인 조건부 타입을 분산 조건부 타입이라고 합니다.\n분산 조건부 타입은 인스턴스화 중에 자동으로 유니언 타입으로 분산됩니다.\n예를 들어, T에 대한 타입 인수 A | B | C를 사용하여 T extends U ? X : Y를 인스턴스화하면 (A extends U ? X : Y) | (B extends U ? X : Y) | (C extends U ? X : Y)로 결정됩니다.\n예제\ntype T10 = TypeName void)>;  // \"string\" | \"function\"\ntype T12 = TypeName;  // \"string\" | \"object\" | \"undefined\"\ntype T11 = TypeName;  // \"object\"\n\n분산 조건부 타입 T extends U ? X : Y의 인스턴스화에서,\n조건부 타입 내의 T에 대한 참조는 유니언 타입의 개별 성분으로 결정됩니다 (즉 T가 조건부 타입이 유니언 타입으로 분산된 후에 개별 성분을 참조합니다).\n게다가, X 안의 T에 대한 참조에는 추가적인 타입 매개변수 제약 조건 (constraint) U가 있습니다 (즉 T는 X 안에서 U에 할당 가능하다고 간주됩니다).\n예제\ntype BoxedValue = { value: T };\ntype BoxedArray = { array: T[] };\ntype Boxed = T extends any[] ? BoxedArray : BoxedValue;\n\ntype T20 = Boxed;  // BoxedValue;\ntype T21 = Boxed;  // BoxedArray;\ntype T22 = Boxed;  // BoxedValue | BoxedArray;\n\nT가 실제 Boxed의 분기 안에서 추가 제약조건 any[]을 가지고 있고 T[number]로 배열의 요소 타입을 참조할 수 있음을 유의하세요. 또한 지난 예제에서 조건부 타입이 어떻게 유니언 타입으로 분산되었는지 확인하세요.\n조건부 타입의 분산 프로퍼티는 유니언 타입을 필터링하는데 편하게 사용할 수 있습니다:\ntype Diff = T extends U ? never : T;  // U에 할당할 수 있는 타입을 T에서 제거\ntype Filter = T extends U ? T : never;  // U에 할당할 수 없는 타입을 T에서 제거\n\ntype T30 = Diff;  // \"b\" | \"d\"\ntype T31 = Filter;  // \"a\" | \"c\"\ntype T32 = Diff void), Function>;  // string | number\ntype T33 = Filter void), Function>;  // () => void\n\ntype NonNullable = Diff;  // T에서 null과 undefined를 제거\n\ntype T34 = NonNullable;  // string | number\ntype T35 = NonNullable;  // string | string[]\n\nfunction f1(x: T, y: NonNullable) {\n    x = y;  // 성공\n    y = x;  // 오류\n}\n\nfunction f2(x: T, y: NonNullable) {\n    x = y;  // 성공\n    y = x;  // 오류\n    let s1: string = x;  // 오류\n    let s2: string = y;  // 성공\n}\n\n조건부 타입은 특히 매핑 타입과 결합할 때 유용합니다.\ntype FunctionPropertyNames = { [K in keyof T]: T[K] extends Function ? K : never }[keyof T];\ntype FunctionProperties = Pick>;\n\ntype NonFunctionPropertyNames = { [K in keyof T]: T[K] extends Function ? never : K }[keyof T];\ntype NonFunctionProperties = Pick>;\n\ninterface Part {\n    id: number;\n    name: string;\n    subparts: Part[];\n    updatePart(newName: string): void;\n}\n\ntype T40 = FunctionPropertyNames;  // \"updatePart\"\ntype T41 = NonFunctionPropertyNames;  // \"id\" | \"name\" | \"subparts\"\ntype T42 = FunctionProperties;  // { updatePart(newName: string): void }\ntype T43 = NonFunctionProperties;  // { id: number, name: string, subparts: Part[] }\n\n유니언과 교차 타입과 유사하게, 조건부 타입은 재귀적으로 자기 자신을 참조할 수 없습니다.\n예를 들어 다음의 예제는 오류입니다.\n예제\ntype ElementType = T extends any[] ? ElementType : T;  // 오류\n\n조건부 타입의 타입 추론 (Type inference in conditional types)\n조건부 타입의 extends 절 안에서, 이제 추론 될 타입 변수를 도입하는 infer 선언을 가지는 것이 가능합니다.\n이렇게 추론된 타입 변수는 조건부 타입의 실제 분기에서 참조될 수 있습니다.\n같은 타입 변수에 대한 여러 개의 infer 위치를 가질 수 있습니다.\n예를 들어, 다음은 함수 타입의 반환 타입을 추출합니다.\ntype ReturnType = T extends (...args: any[]) => infer R ? R : any;\n\n조건부 타입은 순서대로 평가되는 일련의 패턴 일치를 형성하기 위해 중첩될 수 있습니다.\ntype Unpacked =\n    T extends (infer U)[] ? U :\n    T extends (...args: any[]) => infer U ? U :\n    T extends Promise ? U :\n    T;\n\ntype T0 = Unpacked;  // string\ntype T1 = Unpacked;  // string\ntype T2 = Unpacked string>;  // string\ntype T3 = Unpacked>;  // string\ntype T4 = Unpacked[]>;  // Promise\ntype T5 = Unpacked[]>>;  // string\n\n다음 예제는 어떻게 공변 (co-variant) 위치에서 같은 타입 변수에 대한 여러 후보가 유니언 타입을 추론하는지 보여줍니다:\ntype Foo = T extends { a: infer U, b: infer U } ? U : never;\ntype T10 = Foo;  // string\ntype T11 = Foo;  // string | number\n\n마찬가지로, 반-변(contra-variant) 위치에서 같은 타입 변수에 대한 여러 후보가 교차 타입을 추론합니다:\ntype Bar = T extends { a: (x: infer U) => void, b: (x: infer U) => void } ? U : never;\ntype T20 = Bar void, b: (x: string) => void }>;  // string\ntype T21 = Bar void, b: (x: number) => void }>;  // string & number\n\n여러 호출 시그니처가 있는 타입에서 추론할 때 (오버로딩된 함수의 타입과 같은), 추론은 마지막 시그니처에서 만들어집니다 (이는 아마도 가장 관대한 케이스 일 것입니다).\n인수 타입의 리스트를 기반으로 오버로드 해결을 수행할 수는 없습니다.\ndeclare function foo(x: string): number;\ndeclare function foo(x: number): string;\ndeclare function foo(x: string | number): string | number;\ntype T30 = ReturnType;  // string | number\n\n일반 타입 매개변수에 대한 제약조건 절에서 infer 선언을 사용할 수 없습니다.\ntype ReturnType infer R> = R;  // 오류, 지원되지 않습니다.\n\n하지만, 제약조건에서 타입 변수를 지우고 대신에 조건부 타입을 지정하면 거의 같은 효과를 얻을 수 있습니다:\ntype AnyFunction = (...args: any[]) => any;\ntype ReturnType = T extends (...args: any[]) => infer R ? R : any;\n\n미리 정의된 조건부 타입 (Predefined conditional types)\nTypeScript 2.8에서 lib.d.ts에 미리 정의된 조건부 타입을 추가했습니다.\n\nExclude -- U에 할당할 수 있는 타입은 T에서 제외.\nExtract -- U에 할당할 수 있는 타입을 T에서 추출\nNonNullable -- T에서 null과 undefined를 제외.\nReturnType -- 함수 타입의 반환 타입을 얻기.\nInstanceType -- 생성자 함수 타입의 인스턴스 타입을 얻기.\n\n예제\ntype T00 = Exclude;  // \"b\" | \"d\"\ntype T01 = Extract;  // \"a\" | \"c\"\n\ntype T02 = Exclude void), Function>;  // string | number\ntype T03 = Extract void), Function>;  // () => void\n\ntype T04 = NonNullable;  // string | number\ntype T05 = NonNullable string) | string[] | null | undefined>;  // (() => string) | string[]\n\nfunction f1(s: string) {\n    return { a: 1, b: s };\n}\n\nclass C {\n    x = 0;\n    y = 0;\n}\n\ntype T10 = ReturnType string>;  // string\ntype T11 = ReturnType void>;  // void\ntype T12 = ReturnType() => T)>;  // {}\ntype T13 = ReturnType() => T)>;  // number[]\ntype T14 = ReturnType;  // { a: number, b: string }\ntype T15 = ReturnType;  // any\ntype T16 = ReturnType;  // never\ntype T17 = ReturnType;  // 오류\ntype T18 = ReturnType;  // 오류\n\ntype T20 = InstanceType;  // C\ntype T21 = InstanceType;  // any\ntype T22 = InstanceType;  // never\ntype T23 = InstanceType;  // 오류\ntype T24 = InstanceType;  // 오류\n\n\nNote: Exclude 타입은 여기에서 제안된 Diff 타입의 적절한 구현입니다. Diff를 정의한 코드와의 충돌을 피하기 위해 Exclude를 사용했고, 또 이 이름이 타입의 의미를 더 잘 전달한다고 느꼈습니다.\n\n"},"pages/Symbols.html":{"url":"pages/Symbols.html","title":"심볼","keywords":"","body":"소개 (Introduction)\nECMAScript 2015부터, symbol은 number와 string 같은 기본 자료형입니다.\nsymbol 값들은 Symbol생성자를 호출해서 생성합니다.\nlet sym1 = Symbol();\n\nlet sym2 = Symbol(\"key\"); // 선택적 문자열 키\n\n심벌은 불변하며 유일합니다.\nlet sym2 = Symbol(\"key\");\nlet sym3 = Symbol(\"key\");\n\nsym2 === sym3; // false, 심벌은 유일합니다.\n\n문자열처럼, 심벌은 객체 프로퍼티의 키로 사용될 수 있습니다.\nconst sym = Symbol();\n\nlet obj = {\n    [sym]: \"value\"\n};\n\nconsole.log(obj[sym]); // \"value\"\n\n심벌은 계산된 프로퍼티 선언과 결합해 객체 프로퍼티와 클래스 멤버를 선언할 수도 있습니다.\nconst getClassNameSymbol = Symbol();\n\nclass C {\n    [getClassNameSymbol](){\n       return \"C\";\n    }\n}\n\nlet c = new C();\nlet className = c[getClassNameSymbol](); // \"C\"\n\n잘 알려진 심벌들 (Well-known Symbols)\n사용자-정의 심벌 이외에도, 잘 알려진 내장 심벌들이 있습니다.\n내장된 심벌들은 내부 언어 동작을 나타내는 데 사용됩니다.\n다음은 잘 알려진 심벌 목록입니다:\nSymbol.hasInstance\n생성자 객체가 어떤 객체를 생성자의 인스턴스로 인식하는지 확인하는 메서드입니다. instanceof 연산자로 호출됩니다.\nSymbol.isConcatSpreadable\n객체가 자신의 배열 요소를 Array.prototype.concat를 사용하여 직렬로 나타낼 수 있는지를 나타내는 불리언 값입니다.\nSymbol.iterator\n객체의 기본 반복자를 반환하는 메서드입니다. for-of 문으로 호출합니다.\nSymbol.match\n정규식을 문자열과 비교하는 정규식 메서드입니다. String.prototype.match 메서드로 호출합니다.\nSymbol.replace\n일치하는 부분 문자열을 대체하는 정규식 메서드입니다. String.prototype.replace 메서드로 호출합니다.\nSymbol.search\n정규식과 일치하는 문자열의 인덱스를 반환하는 정규식 메서드입니다. String.prototype.search 메서드로 호출합니다.\nSymbol.species\n파생된 객체를 만드는 생성자 함수 프로퍼티 값입니다.\nSymbol.split\n정규식과 일치하는 인덱스들에 위치한 문자열을 분할하는 정규식 메서드입니다.\nString.prototype.split 메서드로 호출합니다.\nSymbol.toPrimitive\n객체를 해당 기본 값으로 변환하는 메서드입니다.\nToPrimitive 추상 연산으로 호출합니다.\nSymbol.toStringTag\n객체의 기본 문자열 설명을 만드는 데 사용되는 문자열 값입니다.\n내장 메소드Object.prototype.toString로 호출합니다.\nSymbol.unscopables\n고유한 프로퍼티 이름들이 연관된 객체의 'with' 환경 바인딩에서 제외된 객체입니다.\n"},"pages/Iterators and Generators.html":{"url":"pages/Iterators and Generators.html","title":"이터레이터와 제네레이터","keywords":"","body":"이터러블 (Iterables)\n객체가 Symbol.iterator프로퍼티에 대한 구현을 가지고 있다면 이터러블로 간주합니다.\nArray, Map, Set, String, Int32Array, Uint32Array 등과 같은 일부 내장 타입에는 이미 Symbol.iterator 프로퍼티가 구현되어 있습니다.\n객체의 Symbol.iterator 함수는 반복할 값 목록을 반환합니다.\nfor..of 문\nfor..of는 객체의 Symbol.iterator 프로퍼티를 호출하여, 이터러블 객체를 반복합니다.\n다음은 배열의 간단한 for..of 루프입니다:\nlet someArray = [1, \"string\", false];\n\nfor (let entry of someArray)\n console.log(entry); // 1, \"string\", false\n}\n\nfor..of vs. for..in 문\nfor..of 및 for..in 문 모두 목록을 반복합니다; 반복되는 값은 다르지만, for..in은 반복되는 객체의 키 목록을 반환하고, 반면에 for..of는 반복되는 객체의 숫자 프로퍼티 값 목록을 반환합니다.\n다음은 이러한 차이점을 보여주는 예입니다.\nlet list = [4, 5, 6];\n\nfor (let i in list){\n console.log(i); // \"0\", \"1\", \"2\"\n}\n\nfor (let i of list){\n console.log(i); // \"4\", \"5\", \"6\"\n}\n\n또 다른 차이점은 for..in은 모든 객체에서 작동한다는 것입니다; 객체의 프로퍼티를 검사하는 방법으로 사용됩니다.\n반면에 for..of는 이터러블 객체의 값에 주로 관심이 있습니다. Map 및 Set과 같은 내장 객체는 저장된 값에 접근할 수 있는 Symbol.iterator 프로퍼티를 구현합니다.\nlet pets = new Set([\"Cat\", \"Dog\", \"Hamster\"]);\npets[\"species\"] = \"mammals\";\n\nfor (let pet in pets){\n console.log(pet); // \"species\"\n}\n\nfor (let pet of pets){\n console.log(pet); // \"Cat\", \"Dog\", \"Hamster\"\n}\n\n코드 생성 (Code generation)\nES5 및 ES3 타게팅 (Targeting ES5 and ES3)\nES5 또는 ES3-호환 엔진을 대상으로 하는 경우, 반복자는 Array 유형의 값만 허용합니다.\n이런 배열이 아닌 값이 Symbol.iterator 프로퍼티를 구현하더라도 배열이 아닌 값에서 for..of 루프를 사용하면 오류가 발생합니다.\n컴파일러는 for..of 루프에 대한 간단한 for 루프를 생성합니다, 예를 들면:\nlet numbers = [1, 2, 3];\nfor (let num of numbers){\n console.log(num);\n}\n\n는 다음과 같이 생성합니다:\nvar numbers = [1, 2, 3];\nfor (var _i = 0; _i \nECMAScript 2015 및 상위 버전 타케팅 (Targeting ECMAScript 2015 and higher)\nECMAScipt 2015-호환 엔진을 타케팅하는 경우, 컴파일러는 엔진의 내장 반복자 구현을 대상으로 하는 for..of 루프를 생성합니다.\n"},"pages/Modules.html":{"url":"pages/Modules.html","title":"모듈","keywords":"","body":"소개 (Introduction)\nECMAScript 2015부터 JavaScript에는 모듈 개념이 있습니다. TypeScript는 이 개념을 공유합니다.\n모듈은 전역 스코프가 아닌 자체 스코프 내에서 실행됩니다; 즉 모듈 내에서 선언된 변수, 함수, 클래스 등은 export 양식 중 하나를 사용하여 명시적으로 export 하지 않는 한 모듈 외부에서 보이지 않습니다.\n반대로 다른 모듈에서 export 한 변수, 함수, 클래스, 인터페이스 등을 사용하기 위해서는 import 양식 중 하나를 사용하여 import 해야 합니다.\n모듈은 선언형입니다; 모듈 간의 관계는 파일 수준의 imports 및 exports 관점에서 지정됩니다.\n모듈은 모듈 로더를 사용하여 다른 모듈을 import 합니다.\n런타임 시 모듈 로더는 모듈을 실행하기 전에 모듈의 모든 의존성을 찾고 실행해야 합니다.\nJavaScript에서 사용하는 유명한 모듈 로더로는 CommonJS 모듈 용 Node.js의 로더와 웹 애플리케이션의 AMD 모듈 용 RequireJS 로더가 있습니다.\nECMAScript 2015와 마찬가지로 TypeScript는 최상위 수준의 import 혹은 export가 포함된 모든 파일을 모듈로 간주합니다.\n반대로 최상위 수준의 import 혹은 export 선언이 없는 파일은 전역 스코프에서 사용할 수 있는 스크립트로 처리됩니다(모듈에서도 마찬가지).\nExport\n선언 export 하기 (Exporting a declaration)\nexport 키워드를 추가하여 모든 선언 (변수, 함수, 클래스, 타입 별칭, 인터페이스)를 export 할 수 있습니다.\nStringValidator.ts\nexport interface StringValidator {\n    isAcceptable(s: string): boolean;\n}\n\nZipCodeValidator.ts\nimport { StringValidator } from \"./StringValidator\";\n\nexport const numberRegexp = /^[0-9]+$/;\n\nexport class ZipCodeValidator implements StringValidator {\n    isAcceptable(s: string) {\n        return s.length === 5 && numberRegexp.test(s);\n    }\n}\n\nExport 문 (Export statements)\nExport 문은 사용자를 위해 export 할 이름을 바꿔야 할 때 편리합니다. 위의 예제는 다음과 같이 작성할 수 있습니다:\nclass ZipCodeValidator implements StringValidator {\n    isAcceptable(s: string) {\n        return s.length === 5 && numberRegexp.test(s);\n    }\n}\nexport { ZipCodeValidator };\nexport { ZipCodeValidator as mainValidator };\n\nRe-export 하기 (Re-exports)\n종종 모듈은 다른 모듈을 확장하고 일부 기능을 부분적으로 노출합니다.\nRe-export 하기는 지역적으로 import 하거나, 지역 변수를 도입하지 않습니다.\nParseIntBasedZipCodeValidator.ts\nexport class ParseIntBasedZipCodeValidator {\n    isAcceptable(s: string) {\n        return s.length === 5 && parseInt(s).toString() === s;\n    }\n}\n\n// 기존 validator의 이름을 변경 후 export\nexport {ZipCodeValidator as RegExpBasedZipCodeValidator} from \"./ZipCodeValidator\";\n\n선택적으로, 하나의 모듈은 하나 혹은 여러 개의 모듈을 감쌀 수 있고, export * from \"module\" 구문을 사용해 export 하는 것을 모두 결합할 수 있습니다.\nAllValidators.ts\nexport * from \"./StringValidator\"; // 'StringValidator' 인터페이스를 내보냄\nexport * from \"./ZipCodeValidator\";  // 'ZipCodeValidator' 와 const 'numberRegexp' 클래스를 내보냄\nexport * from \"./ParseIntBasedZipCodeValidator\"; // 'ParseIntBasedZipCodeValidator' 클래스를 내보냄\n                                                 // 'ZipCodeValidator.ts' 모듈 에 있는\n                                                 // 'ZipCodeValidator' 클래스를\n                                                 // 'RegExpBasedZipCodeValidator' 라는 별칭으로 다시 내보냄\n\nImport\nimport는 모듈에서 export 만큼 쉽습니다.\nexport 한 선언은 아래의 import 양식 중 하나를 사용하여 import 합니다:\n모듈에서 단일 export를 import 하기 (Import a single export from a module)\nimport { ZipCodeValidator } from \"./ZipCodeValidator\";\n\nlet myValidator = new ZipCodeValidator();\n\n이름을 수정해서 import 할 수 있습니다.\nimport { ZipCodeValidator as ZCV } from \"./ZipCodeValidator\";\nlet myValidator = new ZCV();\n\n전체 모듈을 단일 변수로 import 해서, 모듈 exports 접근에 사용하기 (Import the entire module into a single variable, and use it to access the module exports)\nimport * as validator from \"./ZipCodeValidator\";\nlet myValidator = new validator.ZipCodeValidator();\n\n부수효과만을 위해 모듈 import 하기 (Import a module for side-effects only)\n권장되지는 않지만, 일부 모듈은 다른 모듈에서 사용할 수 있도록 일부 전역 상태로 설정합니다.\n이러한 모듈은 어떤 exports도 없거나, 사용자가 exports에 관심이 없습니다.\n이러한 모듈을 import 하기 위해, 다음처럼 사용하세요:\nimport \"./my-module.js\"\n\n타입 import 하기 (Importing Types)\nTypeScript 3.8 이전에는 import를 사용하여 타입을 import 할 수 있었습니다.\nTypeScript 3.8에서는 import 문 혹은 import type을 사용하여 타입을 import 할 수 있습니다.\n// 동일한 import를 재사용하기\nimport {APIResponseType} from \"./api\";\n\n// 명시적으로 import type을 사용하기\nimport type {APIResponseType} from \"./api\";\n\nimport type은 항상 JavaScript에서 제거되며, 바벨 같은 도구는 isolatedModules 컴파일러 플래그를 통해 코드에 대해 더 나은 가정을 할 수 있습니다.\n3.8 릴리즈 정보에서 더 많은 정보를 읽을 수 있습니다.\nDefault exports\n각 모듈은 선택적으로 default export를 export 할 수 있습니다.\ndefault export는 default 키워드로 표시됩니다; 모듈당 하나의 default export만 가능합니다.\ndefault export는 다른 import 양식을 사용하여 import 합니다.\ndefault exports는 정말 편리합니다.\n예를 들어 jQuery와 같은 라이브러리는 jQuery 혹은 $와 같은 default export를 가질 수 있으며, $나 jQuery와 같은 이름으로 import할 수 있습니다.\nJQuery.d.ts\ndeclare let $: JQuery;\nexport default $;\n\nApp.ts\nimport $ from \"jquery\";\n\n$(\"button.continue\").html( \"Next Step...\" );\n\n클래스 및 함수 선언은 default exports로 직접 작성될 수 있습니다.\ndefault export 클래스 및 함수 선언 이름은 선택사항 입니다.\nZipCodeValidator.ts\nexport default class ZipCodeValidator {\n    static numberRegexp = /^[0-9]+$/;\n    isAcceptable(s: string) {\n        return s.length === 5 && ZipCodeValidator.numberRegexp.test(s);\n    }\n}\n\nTest.ts\nimport validator from \"./ZipCodeValidator\";\n\nlet myValidator = new validator();\n\n혹은\nStaticZipCodeValidator.ts\nconst numberRegexp = /^[0-9]+$/;\n\nexport default function (s: string) {\n    return s.length === 5 && numberRegexp.test(s);\n}\n\nTest.ts\nimport validate from \"./StaticZipCodeValidator\";\n\nlet strings = [\"Hello\", \"98052\", \"101\"];\n\n// validate 함수 사용하기\nstrings.forEach(s => {\n  console.log(`\"${s}\" ${validate(s) ? \"matches\" : \"does not match\"}`);\n});\n\ndefault exports는 값도 가능합니다:\nOneTwoThree.ts\nexport default \"123\";\n\nLog.ts\nimport num from \"./OneTwoThree\";\n\nconsole.log(num); // \"123\"\n\nx로 모두 export 하기 (Export all as x)\nTypeScript 3.8에서는 다음 이름이 다른 모듈로 re-export 될 때 단축어처럼 export * as ns를 사용할 수 있습니다:\nexport * as utilities from \"./utilities\";\n\n모듈에서 모든 의존성을 가져와 export한 필드로 만들면, 다음과 같이 import할 수 있습니다:\nimport { utilities } from \"./index\";\n\nexport =와 import = require() (export = and import = require())\nCommonJS와 AMD 둘 다 일반적으로 모듈의 모든 exports를 포함하는 exports 객체의 개념을 가지고 있습니다.\n또한 exports 객체를 사용자 정의 단일 객체로 대체하는 기능도 지원합니다.\ndefault exports는 이 동작에서 대체 역할을 합니다; 하지만 둘은 호환되지는 않습니다.\nTypeScript는 기존의 CommonJS와 AMD 워크플로우를 모델링 하기 위해 export =를 지원합니다.\nexport = 구문은 모듈에서 export되는 단일 객체를 지정합니다.\n클래스, 인터페이스, 네임스페이스, 함수 혹은 열거형이 될 수 있습니다.\nexport =를 사용하여 모듈을 export할 때, TypeScript에 특정한 import module = require(\"module\")를 사용하여 모듈을 가져와야 합니다.\nZipCodeValidator.ts\nlet numberRegexp = /^[0-9]+$/;\nclass ZipCodeValidator {\n    isAcceptable(s: string) {\n        return s.length === 5 && numberRegexp.test(s);\n    }\n}\nexport = ZipCodeValidator;\n\nTest.ts\nimport zip = require(\"./ZipCodeValidator\");\n\n// 시험용 샘플\nlet strings = [\"Hello\", \"98052\", \"101\"];\n\n// 사용할 Validators\nlet validator = new zip();\n\n// 각 문자열이 각 validator를 통과했는지 보여줍니다\nstrings.forEach(s => {\n  console.log(`\"${ s }\" - ${ validator.isAcceptable(s) ? \"matches\" : \"does not match\" }`);\n});\n\n모듈을 위한 코드 생성 (Code Generation for Modules)\n컴파일 중에는 지정된 모듈 대상에 따라 컴파일러는 Node.js (CommonJS), require.js (AMD), UMD, SystemJS, 또는 ECMAScript 2015 native modules (ES6) 모듈-로딩 시스템에 적합한 코드를 생성합니다.\n생성된 코드의 define, require 그리고 register 호출 기능에 대한 자세한 정보는 각 모듈 로더의 문서를 확인하세요.\n이 간단한 예제는 import 및 export 하기 중에 사용된 이름이 모듈 로딩 코드로 변환되는 방법을 보여줍니다.\nSimpleModule.ts\nimport m = require(\"mod\");\nexport let t = m.something + 1;\n\nAMD / RequireJS SimpleModule.js\ndefine([\"require\", \"exports\", \"./mod\"], function (require, exports, mod_1) {\n    exports.t = mod_1.something + 1;\n});\n\nCommonJS / Node SimpleModule.js\nvar mod_1 = require(\"./mod\");\nexports.t = mod_1.something + 1;\n\nUMD SimpleModule.js\n(function (factory) {\n    if (typeof module === \"object\" && typeof module.exports === \"object\") {\n        var v = factory(require, exports); if (v !== undefined) module.exports = v;\n    }\n    else if (typeof define === \"function\" && define.amd) {\n        define([\"require\", \"exports\", \"./mod\"], factory);\n    }\n})(function (require, exports) {\n    var mod_1 = require(\"./mod\");\n    exports.t = mod_1.something + 1;\n});\n\nSystem SimpleModule.js\nSystem.register([\"./mod\"], function(exports_1) {\n    var mod_1;\n    var t;\n    return {\n        setters:[\n            function (mod_1_1) {\n                mod_1 = mod_1_1;\n            }],\n        execute: function() {\n            exports_1(\"t\", t = mod_1.something + 1);\n        }\n    }\n});\n\nNative ECMAScript 2015 modules SimpleModule.js\nimport { something } from \"./mod\";\nexport var t = something + 1;\n\n간단한 예제 (Simple Example)\n아래에서는 각 모듈에서 단일 이름으로 export 하기 위해 이전 예제에서 사용한 Validator 구현을 통합합니다.\n컴파일 하려면, 명령 줄에서 모듈 대상을 지정해야 합니다. Node.js의 경우, --module commonjs를 사용하세요;\nrequire.js의 경우 --module amd를 사용하세요. 예를 들면:\ntsc --module commonjs Test.ts\n\n컴파일이 되면, 각 모듈은 별도의 .js파일이 됩니다.\n참조 태그와 마찬가지로, 컴파일러는 import문을 따라 의존적인 파일들을 컴파일 합니다.\nValidation.ts\nexport interface StringValidator {\n    isAcceptable(s: string): boolean;\n}\n\nLettersOnlyValidator.ts\nimport { StringValidator } from \"./Validation\";\n\nconst lettersRegexp = /^[A-Za-z]+$/;\n\nexport class LettersOnlyValidator implements StringValidator {\n    isAcceptable(s: string) {\n        return lettersRegexp.test(s);\n    }\n}\n\nZipCodeValidator.ts\nimport { StringValidator } from \"./Validation\";\n\nconst numberRegexp = /^[0-9]+$/;\n\nexport class ZipCodeValidator implements StringValidator {\n    isAcceptable(s: string) {\n        return s.length === 5 && numberRegexp.test(s);\n    }\n}\n\nTest.ts\nimport { StringValidator } from \"./Validation\";\nimport { ZipCodeValidator } from \"./ZipCodeValidator\";\nimport { LettersOnlyValidator } from \"./LettersOnlyValidator\";\n\n// 시험용 샘플\nlet strings = [\"Hello\", \"98052\", \"101\"];\n\n// 사용할 validator\nlet validators: { [s: string]: StringValidator; } = {};\nvalidators[\"ZIP code\"] = new ZipCodeValidator();\nvalidators[\"Letters only\"] = new LettersOnlyValidator();\n\n// 각 문자열이 validator를 통과하는지 보여줌\nstrings.forEach(s => {\n    for (let name in validators) {\n        console.log(`\"${ s }\" - ${ validators[name].isAcceptable(s) ? \"matches\" : \"does not match\" } ${ name }`);\n    }\n});\n\n선택적 모듈 로딩과 기타 고급 로딩 시나리오 (Optional Module Loading and Other Advanced Loading Scenarios)\n상황에 따라 특정 조건에서만 모듈을 로드하도록 만들 수 있습니다.\nTypeScript에서는 아래에 있는 패턴을 사용하여 이 시나리오와 다른 고급 로딩 시나리오를 구현하여 타입의 안전성을 잃지 않고 모듈 로더를 직접 호출할 수 있습니다.\n컴파일러는 노출된 JavaScript 안에서 각 모듈의 사용 여부를 감지합니다.\n모듈 식별자가 표현식이 아닌 타입 표시로만 사용된다면 그 모듈에 대한 require 호출은 발생하지 않습니다.\n사용하지 않는 참조를 제거하면 성능을 최적화할 수 있으며, 해당 모듈을 선택적으로 로딩 할 수 있습니다.\n이 패턴의 핵심 아이디어는 import id = require(\"...\") 문을 통해 모듈로 노출된 타입에 접근이 가능하다는 것입니다.\n아래 if 블록에 보이는 것처럼, 모듈 로더는 (require을 통해) 동적으로 호출됩니다.\n이 기능은 참조-제거 최적화를 활용하므로 필요할 때만 모듈을 로드할 수 있습니다.\n해당 패턴이 동작하려면 import를 통해 정의된 심벌은 오직 타입 위치(즉, JavaScript로 방출되는 위치에서는 사용 안 함)에서만 사용되는 것이 중요합니다.\n타입 안전성을 유지하기 위해, typeof 키워드를 사용할 수 있습니다.\ntypeof 키워드는 타입 위치에서 사용될 때는 값의 타입, 이 경우에는 모듈의 타입을 생성합니다.\nNode.js에서 동적 모듈 로딩 (Dynamic Module Loading in Node.js)\ndeclare function require(moduleName: string): any;\n\nimport { ZipCodeValidator as Zip } from \"./ZipCodeValidator\";\n\nif (needZipValidation) {\n    let ZipCodeValidator: typeof Zip = require(\"./ZipCodeValidator\");\n    let validator = new ZipCodeValidator();\n    if (validator.isAcceptable(\"...\")) { /* ... */ }\n}\n\n샘플: require.js에서 동적 모듈 로딩 (Sample: Dynamic Module Loading in require.js)\ndeclare function require(moduleNames: string[], onLoad: (...args: any[]) => void): void;\n\nimport * as Zip from \"./ZipCodeValidator\";\n\nif (needZipValidation) {\n    require([\"./ZipCodeValidator\"], (ZipCodeValidator: typeof Zip) => {\n        let validator = new ZipCodeValidator.ZipCodeValidator();\n        if (validator.isAcceptable(\"...\")) { /* ... */ }\n    });\n}\n\n샘플: System.js에서 동적 모듈 로딩 (Sample: Dynamic Module Loading in System.js)\ndeclare const System: any;\n\nimport { ZipCodeValidator as Zip } from \"./ZipCodeValidator\";\n\nif (needZipValidation) {\n    System.import(\"./ZipCodeValidator\").then((ZipCodeValidator: typeof Zip) => {\n        var x = new ZipCodeValidator();\n        if (x.isAcceptable(\"...\")) { /* ... */ }\n    });\n}\n\n다른 JavaScript 라이브러리와 함께 사용하기 (Working with Other JavaScript Libraries)\nTypeScript로 작성되지 않은 라이브러리의 형태를 설명하려면, 라이브러리를 노출하는 API를 선언해야 합니다.\n우리는 구현을 정의하지 않은 선언을 \"ambient\"라고 부릅니다.\n이 선언들은 일반적으로 .d.ts 파일에 정의되어 있습니다.\nC/C++에 익숙하다면, .h 파일이라고 생각할 수 있습니다.\n몇 가지 예제를 살펴보겠습니다.\nAmbient 모듈 (Ambient Modules)\nNode.js에서는 대부분의 작업은 하나 이상의 모듈을 로드하여 수행합니다.\n최상위-레벨의 내보내기 선언으로 각 모듈을 .d.ts 파일로 정의할 수 있지만, 더 큰 하나의 .d.ts 파일로 모듈들을 작성하는 것이 더 편리합니다.\n이를 위해, ambient 네임스페이스와 유사한 구조를 사용하지만, 나중에 import 할 수 있는 인용된 모듈 이름과 module 키워드를 사용합니다.\n예를 들면:\nnode.d.ts (간단한 발췌)\ndeclare module \"url\" {\n    export interface Url {\n        protocol?: string;\n        hostname?: string;\n        pathname?: string;\n    }\n\n    export function parse(urlStr: string, parseQueryString?, slashesDenoteHost?): Url;\n}\n\ndeclare module \"path\" {\n    export function normalize(p: string): string;\n    export function join(...paths: any[]): string;\n    export var sep: string;\n}\n\n이제 ///  node.d.ts를 수행한 다음, import url = require(\"url\"); 또는 import * as URL from \"url\"을 사용하여 모듈을 로드할 수 있습니다.\n/// \nimport * as URL from \"url\";\nlet myUrl = URL.parse(\"http://www.typescriptlang.org\");\n\n속기 ambient 모듈 (Shorthand ambient modules)\n새로운 모듈을 사용하기 전에 선언을 작성하지 않는 경우, 속기 선언(shorthand declaration)을 사용하여 빠르게 시작할 수 있습니다.\ndeclarations.d.ts\ndeclare module \"hot-new-module\";\n\n속기 모듈로부터 모든 imports는 any 타입을 가집니다.\nimport x, {y} from \"hot-new-module\";\nx(y);\n\n와일드카드 모듈 선언 (Wildcard module declarations)\nSystemJS나\nAMD와 같은 모듈 로더는 비-JavaScirpt 내용을 import 할 수 있습니다.\n이 둘은 일반적으로 접두사 또는 접미사를 사용하여 특수한 로딩 의미를 표시합니다.\n이러한 경우를 다루기 위해 와일드카드 모듈 선언을 사용할 수 있습니다.\ndeclare module \"*!text\" {\n    const content: string;\n    export default content;\n}\n// 일부는 다른 방법으로 사용합니다.\ndeclare module \"json!*\" {\n    const value: any;\n    export default value;\n}\n\n이제 \"*!text\" 나 \"json!*\"와 일치하는 것들을 import 할 수 있습니다.\nimport fileContent from \"./xyz.txt!text\";\nimport data from \"json!http://example.com/data.json\";\nconsole.log(data, fileContent);\n\nUMD 모듈 (UMD modules)\n일부 라이브러리는 많은 모듈 로더에서 사용되거나, 모듈 로딩 (전역 변수) 없이 사용되도록 설계되었습니다.\n이를 UMD 모듈이라고 합니다.\n이러한 라이브러리는 import나 전역 변수를 통해 접근할 수 있습니다.\n예를 들면:\nmath-lib.d.ts\nexport function isPrime(x: number): boolean;\nexport as namespace mathLib;\n\n라이브러리는 모듈 내에서 import로 사용할 수 있습니다:\nimport { isPrime } from \"math-lib\";\nisPrime(2);\nmathLib.isPrime(2); // 오류: 모듈 내부에서 전역 정의를 사용할 수 없습니다.\n\n전역 변수로도 사용할 수 있지만, 스크립트 내에서만 사용할 수 있습니다.\n(스크립트는 imports나 exports가 없는 파일입니다.)\nmathLib.isPrime(2);\n\n모듈 구조화에 대한 지침 (Guidance for structuring modules)\n가능한 최상위-레벨에 가깝게 export 하기 (Export as close to top-level as possible)\n모듈의 사용자가 export 모듈을 사용할 때 가능한 마찰이 적어야 합니다.\n중첩 수준을 과도하게 추가하면 다루기 힘들어지는 경향이 있으므로, 어떻게 구조를 구성할지 신중하게 생각해야 합니다.\n모듈에서 네임스페이스를 export 하는 것은 너무 많은 중첩 레이어를 추가하는 예입니다.\n네임스페이스는 때때로 용도가 있지만, 모듈을 사용할 때 추가적인 레벨의 간접 참조를 추가합니다.\n이것은 사용자에게 금방 고통스러운 지점이 될 수 있고, 일반적으로 불필요합니다.\nexport 한 클래스의 정적 메서드에도 비슷한 문제가 있습니다 - 클래스 자체에 중첩 레이어가 추가됩니다.\n표현이나 의도를 명확하게 유용한 방식으로 높이지 않는 한 간단하게 헬퍼 함수를 export 하는 것을 고려하세요.\n단일 class나 function을  export 할 경우, export default를 사용하세요 (If you're only exporting a single class or function, use export default)\n\"최상위-레벨에 가까운 export\"가 모듈 사용자의 마찰을 줄여주는 것처럼, default export를 도입하는 것도 마찬가지입니다.\n모듈의 주요 목적이 한 개의 특정 export를 저장하는 것이라면, default export로 export 하는 것을 고려하세요.\n이렇게 하면 import 하기와 실제로 import를 사용하기가 더 쉬워집니다.\n예를 들면:\nMyClass.ts\nexport default class SomeType {\n  constructor() { ... }\n}\n\nMyFunc.ts\nexport default function getThing() { return \"thing\"; }\n\nConsumer.ts\nimport t from \"./MyClass\";\nimport f from \"./MyFunc\";\nlet x = new t();\nconsole.log(f());\n\n이것은 사용자에게 최적입니다. 타입에 원하는 이름(이 경우에는 t)을 지정할 수 있고 객체를 찾기 위해 과도한 점을 찍지 않아도 됩니다.\n여러 객체를 export 하는 경우, 최상위-레벨에 두세요 (If you're exporting multiple objects, put them all at top-level)\nMyThings.ts\nexport class SomeType { /* ... */ }\nexport function someFunc() { /* ... */ }\n\n반대로 import 할 때:\nimport 한 이름을 명시적으로 나열 (Explicitly list imported names)\nConsumer.ts\nimport { SomeType, someFunc } from \"./MyThings\";\nlet x = new SomeType();\nlet y = someFunc();\n\n많은 것을 import 하는 경우, 네임스페이스 import 패턴을 사용하세요 (Use the namespace import pattern if you're importing a large number of things)\nMyLargeModule.ts\nexport class Dog { ... }\nexport class Cat { ... }\nexport class Tree { ... }\nexport class Flower { ... }\n\nConsumer.ts\nimport * as myLargeModule from \"./MyLargeModule.ts\";\nlet x = new myLargeModule.Dog();\n\n상속을 위한 re-export 하기 (Re-export to extend)\n종종 모듈의 기능을 확장해야 할 필요가 있습니다.\n일반적인 JS 패턴은 JQuery 확장이 작동하는 방식과 유사하게 확장(extensions)으로 기존의 객체를 보강하는 것입니다.\n앞에서 언급했듯이 모듈은 전역 네임스페이스 객체와 같이 병합(merge) 하지 않습니다.\n여기서 추천하는 방법은 기존의 객체를 변형하지 않고 새로운 기능을 제공하는 개체를 export 하는 것입니다.\nCalculator.ts 모듈에 정의된 간단한 계산기 구현을 생각해보세요.\n이 모듈도 입력 문자열 목록을 전달하고 결과를 작성하여 계산기의 기능을 테스트할 수 있는 헬퍼 함수를 export 합니다.\nCalculator.ts\nexport class Calculator {\n    private current = 0;\n    private memory = 0;\n    private operator: string;\n\n    protected processDigit(digit: string, currentValue: number) {\n        if (digit >= \"0\" && digit = 0) {\n            return operator;\n        }\n    }\n\n    protected evaluateOperator(operator: string, left: number, right: number): number {\n        switch (this.operator) {\n            case \"+\": return left + right;\n            case \"-\": return left - right;\n            case \"*\": return left * right;\n            case \"/\": return left / right;\n        }\n    }\n\n    private evaluate() {\n        if (this.operator) {\n            this.memory = this.evaluateOperator(this.operator, this.memory, this.current);\n        }\n        else {\n            this.memory = this.current;\n        }\n        this.current = 0;\n    }\n\n    public handleChar(char: string) {\n        if (char === \"=\") {\n            this.evaluate();\n            return;\n        }\n        else {\n            let value = this.processDigit(char, this.current);\n            if (value !== undefined) {\n                this.current = value;\n                return;\n            }\n            else {\n                let value = this.processOperator(char);\n                if (value !== undefined) {\n                    this.evaluate();\n                    this.operator = value;\n                    return;\n                }\n            }\n        }\n        throw new Error(`Unsupported input: '${char}'`);\n    }\n\n    public getResult() {\n        return this.memory;\n    }\n}\n\nexport function test(c: Calculator, input: string) {\n    for (let i = 0; i \n노출된 test 함수를 사용하는 간단한 계산기 테스트입니다.\nTestCalculator.ts\nimport { Calculator, test } from \"./Calculator\";\n\n\nlet c = new Calculator();\ntest(c, \"1+2*33/11=\"); // 9 출력\n\n10이 아닌 숫자를 입력받을 수 있도록 이것을 상속하여 ProgrammerCalculator.ts을 만들어보겠습니다.\nProgrammerCalculator.ts\nimport { Calculator } from \"./Calculator\";\n\nclass ProgrammerCalculator extends Calculator {\n    static digits = [\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"A\", \"B\", \"C\", \"D\", \"E\", \"F\"];\n\n    constructor(public base: number) {\n        super();\n        const maxBase = ProgrammerCalculator.digits.length;\n        if (base  maxBase) {\n            throw new Error(`base has to be within 0 to ${maxBase} inclusive.`);\n        }\n    }\n\n    protected processDigit(digit: string, currentValue: number) {\n        if (ProgrammerCalculator.digits.indexOf(digit) >= 0) {\n            return currentValue * this.base + ProgrammerCalculator.digits.indexOf(digit);\n        }\n    }\n}\n\n// 새로 상속된 calculator를 Calculator로 export 하기\nexport { ProgrammerCalculator as Calculator };\n\n// 또한 헬퍼 함수도 export 하기\nexport { test } from \"./Calculator\";\n\n새로운 ProgrammerCalculator 모듈은 Calculator 모듈과 유사한 API 형태를 export 하지만, 원래 모듈의 객체를 보강하지는 않습니다.\n다음은 ProgrammerCalculator 클래스에 대한 테스트입니다:\nTestProgrammerCalculator.ts\nimport { Calculator, test } from \"./ProgrammerCalculator\";\n\nlet c = new Calculator(2);\ntest(c, \"001+010=\"); // 3 출력\n\n모듈에서 네임스페이스를 사용하지 마세요 (Do not use namespaces in modules)\n모듈 기반 구성을 처음 적용할 때, 일반적으로 추가적인 네임스페이스 계층에서 exports를 래핑 하는 경향이 있습니다.\n모듈에는 자체 스코프가 있으며, export된 선언만 모듈 외부에서 볼 수 있습니다.\n이를 염두에 두고 네임스페이스는 모듈을 다룰 때 거의 값을 변경하지 않습니다.\n구성 전면에서 네임스페이스는 논리적으로 관련된 개체와 타입을 전역 스코프로 그룹화하는데 편리합니다.\n예를 들어, C#의 경우, System.Collections에서 모든 컬렉션 타입을 찾을 수 있습니다.\n타입을 계층적 네임스페이스로 구성하여 해당 타입의 사용자에게 \"발견\"할 수 있는 좋은 경험을 제공합니다.\n반면, 모듈은 이미 파일 시스템에 반드시 존재합니다.\n경로와 파일 이름으로 해석하기 위해서, 논리적 구성 체계를 사용할 수 있습니다.\n리스트 모듈이 있는 /collections/generic/ 폴더를 사용할 수 있습니다.\n네임스페이스는 전역 스코프에서 네이밍 충돌을 피하기 위해 중요합니다.\n예를 들어, My.Application.Customer.AddForm과 My.Application.Order.AddForm -- 두 타입의 이름은 같지만 다른 네임스페이스를 가지고 있습니다.\n그러나 이것은 모듈에서 문제가 되지 않습니다.\n모듈 내에서 두 개의 객체가 같은 이름을 가질만한 이유는 없습니다.\n사용 측면에서 특정 모듈의 사용자는 모듈을 참조하는데 사용할 이름을 선택하므로 우연한 이름 충돌은 불가능합니다.\n\n모듈과 네임스페이스에 대한 자세한 내용은 Namespaces and Modules를 참고하세요\n\n위험 신호 (Red Flags)\n다음은 모두 모듈 구조화에 대한 위험 신호입니다. 다음 중 하나라도 파일에 적용되는 경우 외부 모듈의 네임스페이스를 만들려고 하지 않았는지 다시 확인하세요:\n\n오직 최상위-레벨 선언만 export namespace Foo { ... }인 파일 (Foo를 제거하고 모든 것을 '상위' 레벨로 이동하세요)\n최상위-레벨 위치에 동일한 export namespace Foo {를 가진 여러 파일 (하나의 Foo로 결합될 거라 생각하지 마세요!)\n\n"},"pages/Namespaces.html":{"url":"pages/Namespaces.html","title":"네임스페이스","keywords":"","body":"목차 (Table of Contents)\n소개 (Introduction)  \n첫 번째 단계 (First steps)  \n\n단일 파일 검사기 (Validators in a single file)  \n\n네임스페이스 적용하기 (Namespacing)  \n\nNamespaced Validators  \n\n파일 간 분할 (Splitting Across Files)  \n\n다중 파일 네임 스페이스 (Multi-file namespaces)  \n\n별칭 (Aliases)  \n다른 JavaScript 라이브러리로 작업하기 (Working with Other JavaScript Libraries)  \n\nAmbient 네임스페이스 (Ambient Namespaces)  \n\n소개 (Introduction)\n↥ 위로\n이 게시물에서는 TypeScript에서 네임스페이스를 사용하여 코드를 구성하는 다양한 방법을 간략하게 설명합니다.\n첫 번째 단계 (First steps)\n↥ 위로\n이 페이지 전체에서 예제로 사용할 프로그램을 시작하겠습니다.\n웹 페이지의 양식에 대한 사용자 입력을 확인하거나 외부로부터 받은 데이터 파일의 형식을 확인하기 위해 간단한 문자열 검사기 세트를 작성했습니다.\n단일 파일 검사기 (Validators in a single file)\ninterface StringValidator {\n    isAcceptable(s: string): boolean;\n}\n\nlet lettersRegexp = /^[A-Za-z]+$/;\nlet numberRegexp = /^[0-9]+$/;\n\nclass LettersOnlyValidator implements StringValidator {\n    isAcceptable(s: string) {\n        return lettersRegexp.test(s);\n    }\n}\n\nclass ZipCodeValidator implements StringValidator {\n    isAcceptable(s: string) {\n        return s.length === 5 && numberRegexp.test(s);\n    }\n}\n\n// 시도해 볼 샘플\nlet strings = [\"Hello\", \"98052\", \"101\"];\n\n// 사용할 검사기\nlet validators: { [s: string]: StringValidator; } = {};\nvalidators[\"ZIP code\"] = new ZipCodeValidator();\nvalidators[\"Letters only\"] = new LettersOnlyValidator();\n\n// 각 문자열이 각 검사기를 통과했는지 표시\nfor (let s of strings) {\n    for (let name in validators) {\n        let isMatch = validators[name].isAcceptable(s);\n        console.log(`'${ s }' ${ isMatch ? \"matches\" : \"does not match\" } '${ name }'.`);\n    }\n}\n\n네임스페이스 적용하기 (Namespacing)\n더 많은 검사기를 추가하게 되면, 타입을 추적하고 다른 객체와 이름 충돌을 방지하기 위해 일종의 구조 체계가 필요합니다.\n전역 네임스페이스에 다른 이름을 많이 넣는 대신, 객체들을 하나의 네임스페이스로 감싸겠습니다.\n이 예에서는 모든 검사기 관련 개체를 Validation이라는 하나의 네임스페이스로 옮기겠습니다.여기서 인터페이스 및 클래스가 네임스페이스 외부에서도 접근 가능하도록 선언부에 export를 붙입니다.반면, 변수 letterRegexp와 numberRegexp는 구현 세부 사항이므로 외부로 내보내지 않아 네임스페이스 외부 코드에서 접근할 수 없습니다.\n파일 하단의 테스트 코드에서, 네임스페이스 외부에서 사용될 때 타입의 이름을 검증해야 합니다 (예: Validation.LetterOnlyValidator).\n네임스페이스화된 검사기 (Namespaced Validators)\nnamespace Validation {\n    export interface StringValidator {\n        isAcceptable(s: string): boolean;\n    }\n\n    const lettersRegexp = /^[A-Za-z]+$/;\n    const numberRegexp = /^[0-9]+$/;\n\n    export class LettersOnlyValidator implements StringValidator {\n        isAcceptable(s: string) {\n            return lettersRegexp.test(s);\n        }\n    }\n\n    export class ZipCodeValidator implements StringValidator {\n        isAcceptable(s: string) {\n            return s.length === 5 && numberRegexp.test(s);\n        }\n    }\n}\n\n// 시도해 볼 샘플\nlet strings = [\"Hello\", \"98052\", \"101\"];\n\n// 사용할 검사기\nlet validators: { [s: string]: Validation.StringValidator; } = {};\nvalidators[\"ZIP code\"] = new Validation.ZipCodeValidator();\nvalidators[\"Letters only\"] = new Validation.LettersOnlyValidator();\n\n// 각 문자열이 각 검사기를 통과했는지 표시\nfor (let s of strings) {\n    for (let name in validators) {\n        console.log(`\"${ s }\" - ${ validators[name].isAcceptable(s) ? \"matches\" : \"does not match\" } ${ name }`);\n    }\n}\n\n파일 간 분할 (Splitting Across Files)\n↥ 위로\n애플리케이션 규모가 커지면, 코드를 여러 파일로 분할해야 유지 보수가 용이합니다.  \n다중 파일 네임스페이스 (Multi-file namespaces)\n↥ 위로\n여기서 Validation 네임스페이스를 여러 파일로 분할합니다.\n파일이 분리되어 있어도 같은 네임스페이스에 기여할 수 있고 마치 한 곳에서 정의된 것처럼 사용할 수 있습니다.\n파일 간 의존성이 존재하므로, 참조 태그를 추가하여 컴파일러에게 파일 간의 관계를 알립니다.\n그 외에 테스트 코드는 변경되지 않았습니다.\nValidation.ts\nnamespace Validation{\n    export interface StringValidator{\n        isAcceptable(s: string): boolean;\n    }\n}\n\nLettersOnlyValidators.ts\n/// \nnamespace Validation {\n    const lettersRegexp = /^[A-Za-z]+$/;\n    export class LettersOnlyValidator implements StringValidator {\n        isAcceptable(s: string) {\n            return lettersRegexp.test(s);\n        }\n    }\n}\n\nZipCodeValidators.ts\n/// \nnamespace Validation {\n    const numberRegexp = /^[0-9]+$/;\n    export class ZipCodeValidator implements StringValidator {\n        isAcceptable(s: string) {\n            return s.length === 5 && numberRegexp.test(s);\n        }\n    }\n}\n\nTest.ts\n/// \n/// \n/// \n\n// Some samples to try\nlet strings = [\"Hello\", \"98052\", \"101\"];\n\n// Validators to use\nlet validators: { [s: string]: Validation.StringValidator; } = {};\nvalidators[\"ZIP code\"] = new Validation.ZipCodeValidator();\nvalidators[\"Letters only\"] = new Validation.LettersOnlyValidator();\n\n// Show whether each string passed each validator\nfor (let s of strings) {\n    for (let name in validators) {\n        console.log(`\"${ s }\" - ${ validators[name].isAcceptable(s) ? \"matches\" : \"does not match\" } ${ name }`);\n    }\n}\n\n파일이 여러 개 있으면 컴파일된 코드가 모두 로드되는지 확인해야 합니다.\n이를 수행하는 두 가지 방법이 있습니다.\n먼저, 모든 입력 파일을 하나의 JavaScript 출력 파일로 컴파일하기 위해 --outFile 플래그를 사용하여 연결 출력(concatenated output)을 사용할 수 있습니다:\ntsc --outFile sample.js Test.ts\n\n컴파일러는 파일에 있는 참조 태그를 기반으로 출력 파일을 자동으로 정렬합니다. 각 파일을 개별적으로 지정할 수도 있습니다:\ntsc --outFile sample.js Validation.ts LettersOnlyValidator.ts ZipCodeValidator.ts Test.ts\n\n또는 파일별 컴파일 (기본값)을 사용하여 각 입력 파일을 하나의 JavaScript 파일로 생성할 수 있습니다.\n여러 JS 파일이 생성되는 경우, 웹 페이지에서 생성된 개별 파일을 적절한 순서로 로드하기 위해  태그를 사용해야 합니다. 예를 들어:\nMyTestPage.html (인용)\n    \n    \n    \n    \n\n별칭 (Aliases)\n↥ 위로\n네임스페이스 작업을 단순화할 수 있는 또 다른 방법은 일반적으로 사용되는 객체의 이름을 더 짧게 만들기 위해 import q = x.y.z를 사용하는 것입니다.\n모듈을 로드하는 데 사용되는 import x = require (\"name\") 구문과 혼동하지 않기 위해, 이 구문은 단순히 특정 심벌에 별칭을 생성합니다.\n이러한 종류의 가져오기(일반적으로 별칭이라고 함)는 모듈 가져오기에서 생성된 객체를 포함하여 모든 종류의 식별자에 대해 사용할 수 있습니다.\nnamespace Shapes {\n    export namespace Polygons {\n        export class Triangle { }\n        export class Square { }\n    }\n}\n\nimport polygons = Shapes.Polygons;\nlet sq = new polygons.Square(); // 'new Shapes.Polygons.Square()'와 동일\n\nrequire 키워드를 사용하지 않는다는 것을 명심하세요; 대신 가져오는 심벌은 정해진 이름으로 직접 할당합니다.\nvar를 사용하는 것과 비슷하지만, 가져온 심벌의 타입 및 네임스페이스 의미에 대해서도 동작합니다.\n특히, 값의 경우 import는 원래 심벌와 별개의 참조이므로 별칭 var에 대한 변경 내용은 원래 변수에 반영되지 않습니다.\n다른 JavaScript 라이브러리로 작업하기 (Working with Other JavaScript Libraries)\n↥ 위로\nTypeScript로 작성되지 않은 라이브러리의 형태를 설명하려면, 라이브러리가 외부에 제공하는 API를 선언해야 합니다.\n대부분의 JavaScript 라이브러리는 소수의 최상위 객체만 노출하므로 네임스페이스를 사용하는 것이 좋습니다.\n구현을 정의하지 않은 선언을 \"ambient\"라고 부릅니다.\n일반적으로 이것은 .d.ts 파일에 정의되어 있습니다.\nC/C++에 익숙하다면 이를 .h 파일로 생각할 수 있습니다.\n몇 가지 예를 살펴보겠습니다.\nAmbient 네임스페이스 (Ambient Namespaces)\n↥ 위로\n널리 사용되는 D3 라이브러리는 d3이라는 전역 객체에서 기능을 정의합니다.\n이 라이브러리는  태그를 통해 로드되므로(모듈 로더 대신) 형태를 정의하기 위해 선언할 때 네임스페이스를 사용합니다.\nTypeScript 컴파일러는 이 형태를 보기 위해, ambient 네임스페이스 선언을 사용합니다.\n예를 들어 다음과 같이 작성할 수 있습니다:\nD3.d.ts (간단한 인용)\ndeclare namespace D3 {\n    export interface Selectors {\n        select: {\n            (selector: string): Selection;\n            (element: EventTarget): Selection;\n        };\n    }\n\n    export interface Event {\n        x: number;\n        y: number;\n    }\n\n    export interface Base extends Selectors {\n        event: Event;\n    }\n}\n\ndeclare var d3: D3.Base;\n\n"},"pages/Namespaces and Modules.html":{"url":"pages/Namespaces and Modules.html","title":"네임스페이스와 모듈","keywords":"","body":"소개 (Introduction)\n이 글에서는 TypeScript에서 모듈과 네임스페이스를 사용하여 코드를 구성하는 다양한 방법을 간략하게 설명합니다.\n또한 네임스페이스와 모듈에 관한 몇 가지 고급 주제와 TypeScript에서 네임스페이스와 모듈을 사용할 때 흔히 마주치는 위험성을 살펴볼 것입니다.\nES 모듈에 대한 자세한 내용은 모듈 문서를 참고하세요.\nTypeScript 네임스페이스에 대한 자세한 내용은 네임스페이스 문서를 참고하세요.\n참고: 매우 오래된 버전의 TypeScript 네임스페이스는 이전의 JavaScript 모듈 시스템인 '내부 모듈'이라고 불렸습니다.\n모듈 사용하기 (Using Modules)\n모듈에는 코드와 선언 둘 다 포함될 수 있습니다.\n모듈은 또한 모듈 로더(예: CommonJs/Require.js)에 대한 의존성이나 ES 모듈이 지원하는 런타임을 가지고 있습니다.\n모듈은 더 나은 코드 재사용성을 위해, 강력한 고립성과 번들링을 위한 향상된 도구를 제공합니다.\n또한 Node.js 애플리케이션의 경우 모듈이 기본적인 방법이며, 코드를 구조화하는 데 있어 권장하는 접근법이라는 점을 유의해야 합니다.\nECMAScript 2015부터, 모듈은 언어에서 기본적으로 내재한 부분이며, 모든 호환 엔진 구현은 모듈을 지원해야 합니다.\n따라서, 새로운 프로젝트의 경우 코드를 구성하는 방법으로 모듈을 권장합니다.\n네임스페이스 사용하기 (Using Namespaces)\n네임스페이스는 코드를 구성하는 TypeScript만의 고유한 방법입니다.\n네임스페이스는 간단히 전역 네임스페이스에서 JavaScript 객체로 이름 붙여집니다.\n이러한 점 덕분에 네임스페이스를 아주 단순한 구조로 사용할 수 있습니다.\n모듈과 달리, 여러 개의 파일을 포괄할 수 있으며, --outFile을 사용해 연결할 수 있습니다.\n네임스페이스는 웹 애플리케이션에서 코드를 구조화하기에 좋은 방법이며, 모든 의존성은 HTML 페이지의  태그로 포함합니다.\n특히 대규모 애플리케이션의 경우, 이 방법은 모든 전역 네임스페이스가 오염되는 경우와 마찬가지로 컴포넌트의 의존성을 식별하기 힘들게 만들 수 있습니다.\n네임스페이스와 모듈의 위험성 (Pitfalls of Namespaces and Modules)\n여기서는 네임스페이스와 모듈을 사용할 때 자주 발생하는 다양한 위험성과 그 해결책을 알아보겠습니다.\n/// 를 사용한 모듈\n일반적인 실수는 모듈 파일을 참조하기 위해 import문 대신 ///  구문을 사용하는 것입니다.\n이 둘의 차이를 이해하기 위해, 우선 import 경로에 위치한 모듈에 대한 타입 정보를 컴파일러가 어떻게 찾아내는지를 이해해야 합니다. (예를 들어, import x from \"...\";, import x = require(\"...\"); 등 안의 ...)\n컴파일러는 .ts, .tsx를 찾은 다음 적절한 경로에 위치한 .d.ts를 찾습니다.\n만약 특정 파일을 찾지 못한다면, 컴파일러는 앰비언트 모듈(ambient module) 선언을 탐색할 것입니다.\n.d.ts 파일안에 이것들을 선언해야 한다는 점을 기억하세요.\n\nmyModules.d.ts\n// 모듈이 아닌 .d.ts 파일 또는 .ts 파일:\ndeclare module \"SomeModule\" {\n    export function fn(): string;\n}\n\n\nmyOtherModule.ts\n/// \nimport * as m from \"SomeModule\";\n\n\n\n위의 reference 태그는 앰비언트 모듈(ambient module) 선언이 포함된 선언 파일의 위치를 지정하는 데 필요합니다.\n이 방법은 여러 TypeScript 샘플에서 사용하는 node.d.ts파일을 사용하는 방법입니다.\n불필요한 네임스페이스 (Needless Namespacing)\n네임스페이스를 사용하던 프로그램을 모듈로 변경하면, 파일은 다음과 같은 모습이 되기 쉽습니다:\n\nshapes.ts\nexport namespace Shapes {\n    export class Triangle { /* ... */ }\n    export class Square { /* ... */ }\n}\n\n\n\n최상위 모듈 Shapes는 아무런 의미 없이 Triangle과 Square을 감싸고 있습니다.\n이런 점은 모듈 사용자에게 혼동과 짜증을 유발합니다:\n\nshapeConsumer.ts\nimport * as shapes from \"./shapes\";\nlet t = new shapes.Shapes.Triangle(); // shapes.Shapes?\n\n\n\nTypeScript 모듈의 중요한 특징 중 하나는 서로 다른 두 개의 모듈이 절대 같은 스코프 안에 이름을 제공하지 않는다는 점입니다.\n모듈 사용자가 어떤 이름을 할당할지를 결정하기 때문에, 네임스페이스 내부에서 내보내는 심벌을 미리 감싸줄 필요가 없습니다.\n모듈 내용의 네임스페이스를 설정하지 않아도 되는 이유를 다시 말하면, 네임스페이스를 지정하는 일반적인 목적은 구조의 논리적 그룹을 제공하고 이름 충돌을 방지하기 위함입니다.\n모듈 파일이 이미 스스로 논리적 그룹을 형성하고 있기 때문에, 최상위 이름은 이를 가져오는 코드에 의해 정의되고, 내보내는 객체를 위한 추가적인 모듈 계층을 사용할 필요가 없습니다.\n다음은 수정된 예입니다:\n\nshapes.ts\nexport class Triangle { /* ... */ }\nexport class Square { /* ... */ }\n\n\nshapeConsumer.ts\nimport * as shapes from \"./shapes\";\nlet t = new shapes.Triangle();\n\n\n\n모듈의 트레이드-오프 (Trade-offs of Modules)\nJS 파일과 모듈이 일대일 대응인 것처럼, TypeScript는 모듈 소스 파일과 이 파일에서 생성된 JS 파일도 일대일 대응입니다.\n이러한 특성 때문에 어떤 모듈 시스템을 사용하느냐에 따라서 여러 모듈 소스 파일을 합치는 작업이 불가능할 수 있습니다.\n예를 들어, commonjs 또는 umd를 대상으로 하는 동안에는 outFile 옵션을 사용할 수 없지만,   TypeScript 1.8 이후부터, amd 또는 system를 대상으로 하는 경우에는 outFile 옵션을 사용할 수 있게 되었습니다.\n"},"pages/Module Resolution.html":{"url":"pages/Module Resolution.html","title":"모듈 해석","keywords":"","body":"\n이번 섹션은 모듈에 대한 기초적인 지식을 전제로 합니다.\n더 많은 정보는 모듈을 보도록 하세요.\n\n모듈 해석 (module resolution) 은 컴파일러가 imoprt가 무엇을 참조하는지 알아내기 위해 사용하는 프로세스입니다.\nimport { a } from \"moduleA\"같은 import 문을 생각해보세요;\na의 모든 사용을 검사하기 위해, 컴파일러는 무엇을 참조하는지 정확히 알아야 할 필요가 있습니다, 그리고 moduleA 정의를 검사해야 할 필요가 있습니다.\n이 시점에, 컴파일러는 \"moduleA의 형태가 뭘까?\"라고 질문할 것입니다.\n간단해 보이지만, moduleA는 .ts/.tsx 파일에 정의되어 있거나 혹은 코드가 의존하는 .d.ts에 정의되어 있을 수 있습니다.\n첫 번째로, 컴파일러는 가져온 모듈을 나타내는 파일의 위치를 찾으려고 할 것입니다.\n그렇게 하기 위해 컴파일러는 두 가지 다른 전략 중 하나를 따릅니다: 클래식 혹은 [노드][#노드-node].\n이 전략들은 컴파일러가 moduleA를 찾기 위해 어디를 봐야 할지 알려줍니다.\n만약 이 방법이 잘 안되고 모듈 이름이 비-상대적이라면 (\"moduleA의 경우가 그렇습니다), 컴파일러는 ambient 모듈 선언을 찾으려고 할 것입니다.\n비-상대적 import는 다음에 다룰 것입니다.\n마지막으로, 컴파일러가 모듈을 해석할 수 없다면, 오류 로그가 발생합니다.\n이 경우에, 오류는 error TS2307: Cannot find module 'moduleA와 같습니다.\n상대적 vs. 비-상대적 모듈 import (Relative vs. Non-relative module imports)\n모듈 참조가 상대적 혹은 비-상대적이냐에 따라 모듈 import는 다르게 해석됩니다.\n상대적 import 는 /, ./ 혹은 ../. 중에 하나로 시작합니다.\n일부 예제는 다음과 같습니다:\n\nimport Entry from \"./components/Entry\";\nimport { DefaultHeaders } from \"../constants/http\";\nimport \"/mod\";\n\n다른 모든 import는 비-상대적 으로 간주됩니다.\n일부 예제는 다음과 같습니다:\n\nimport * as $ from \"jquery\";\nimport { Component } from \"@angular/core\";\n\n상대적 import는 가져온 파일에 상대적으로 해석되고 ambient 모듈 선언으로 해석 될 수 없습니다.\n자신의 모듈에 대해서는 런타임에 상대적 위치를 유지하는 것을 보장하는 상대적 import를 사용해야 합니다.\n비-상대적 import는 baseUrl로 해석되거나, 밑에서 다루게 될 경로 매핑으로 해석될 수 있습니다.\nambient 모듈 선언으로도 해석될 수 있습니다.\n외부 의존성을 import 할 때, 비-상대적 경로를 사용하세요.\n모듈 해석 전략 (Module Resolution Strategies)\n두 가지 가능한 모듈 해석 전략이 있습니다: 노드와 클래식.\n--moduleResolution 플래그를 사용하여 모듈 해석 전략을 지정할 수 있습니다.\n지정되지 않았으면, 디폴트는 --module AMD | System | ES2015에서는 [클래식][#클래식-classic]이고 나머지는 노드입니다.\n클래식 (Classic)\nTypeScript의 디폴트 해석 전략으로 사용됩니다.\n요즘에, 이 전략은 주로 이전 버전과의 호환성을 위해 제공됩니다.\n상대적 import는 import하는 파일에 상대적으로 해석됩니다.\n그래서 소스 파일 /root/src/folder/A.ts안에 import { b } from \"./moduleB\"`는 다음과 같이 조회합니다:\n\n/root/src/folder/moduleB.ts\n/root/src/folder/moduleB.d.ts\n\n그러나, 비-상대적 모듈 import에서는, 컴파일러가 가져온 파일을 갖고 있는 디렉터리부터 시작해서 디렉터리 트리를 거슬러 올라가 맞는 정의 파일의 위치를 찾으려고 합니다.\n예를 들어:\n소스 파일 /root/src/folder/A.ts안에 import { b } from \"moduleB\"처럼 moduleB의 비-상대적 import은 \"moduleB\"의 위치를 찾기 위해 다음과 같은 위치를 찾습니다.\n\n/root/src/folder/moduleB.ts\n/root/src/folder/moduleB.d.ts\n/root/src/moduleB.ts\n/root/src/moduleB.d.ts\n/root/moduleB.ts\n/root/moduleB.d.ts\n/moduleB.ts\n/moduleB.d.ts\n\n노드 (Node)\n이 해석 전략은 런타임에 Node.js의 모듈 해석 메커니즘을 모방하려고 시도합니다.\n전체 Node.js 해석 알고리즘은 Node.js 모듈 문서에 요약되어 있습니다.\nNode.js가 모듈을 해석하는 방법 (How Node.js resolves modules)\nTS 컴파일러가 어떤 과정을 따를지 이해하기 위해서는, Node.js 모듈을 이해하는 것이 중요합니다.\n전통적으로, Node.js의 import는 require 함수를 호출해 수행합니다.\nNode.js의 동작은 require에 상대적 경로 혹은 비-상대적 경로가 주어지는지에 따라 달라집니다.\n상대적 경로는 아주 간단합니다.\n예를 들어, var x = require(\"./moduleB\");라는 import 문을 포함한 /root/src/moduleA.js에 위치한 파일을 생각해봅시다.\nNode.js는 다음 순서로 import를 해석합니다:\n\n/root/src/moduleB.js라는 파일이 존재하는지 확인.\n\n만약 \"main\" 모듈을 지정하는 package.json라는 파일을 포함하고 있으면, /root/src/moduleB 폴더 확인하기.\n이 예제에서는, 만약 Node.js가 { \"main\": \"lib/mainModule.js\" }을 포함하는 /root/src/moduleB/package.json파일을 찾았다면, Node.js가 /root/src/moduleB/lib/mainModule.js를 참조할 것입니다.\n\nindex.js 라는 파일을 포함하고 있으면, /root/src/moduleB 확인하기.\n 이 파일은 폴더의 \"main\" 모듈임을 암시적으로 나타냅니다.\n\n\n자세한 내용은 Node.js 문서 파일 모듈과 폴더 모듈에서 더 읽어보실 수 있습니다.\n그러나, 비-상대적 모듈 이름에 대한 해석은 다르게 수행합니다.\nNode는 node_modules로 불리는 특별한 폴더에서 모듈을 찾을 것입니다.\nnode_modules 폴더는 현재 파일과 동일한 레벨이거나, 디렉터리 체인에서 더 높을 수도 있습니다.\nNode는 디렉터리 체인을 올라가, 로드하려는 모듈을 찾을 때까지 각 node_modules을 찾습니다.\n위의 예제를 따라서, /root/src/moduleA.js가 대신 비-상대적 경로를 사용하고 var x = require(\"moduleB\"); import를 가지고 있다고 생각해봅시다.\nNode는 하나가 일치할 때까지 각 위치에서 moduleB를 해석하려고 시도합니다.\n\n/root/src/node_modules/moduleB.js\n/root/src/node_modules/moduleB/package.json (\"main\" 항목을 지정했다면)\n/root/src/node_modules/moduleB/index.js\n\n/root/node_modules/moduleB.js\n/root/node_modules/moduleB/package.json (\"main\" 항목을 지정했다면)\n/root/node_modules/moduleB/index.js\n\n/node_modules/moduleB.js\n/node_modules/moduleB/package.json (\"main\" 항목을 지정했다면)\n/node_modules/moduleB/index.js\n\nNode.js가 (4) 와 (7)에서 디렉터리를 점프했다는 것에 주목하세요.\n프로세스에 대한 더 많은 정보는 Node.js 문서 node_modules에서 모듈 로드하기에서 읽어보실 수 있습니다.\nTypeScript가 모듈을 해석하는 방법 (How TypeScript resolves modules)\nTypeScript는 컴파일-타임에 모듈의 정의 파일 위치를 찾기 위해 Node.js의 런타임 해석 전략을 모방합니다.\n이를 달성하기 위해, TypeScript는 TypeScript 소스 파일 확장자 (.ts, .tsx 와 .d.ts)를 Node의 해석 로직 위에 씌웁니다.\nTypeScript는 \"main\"의 목적 - 컴파일러가 이를 사용하여 참조할 \"main\" 정의 파일을 찾음. 을 반영하기 위해 \"types\"라는 package.json안에 필드를 사용합니다\n예를 들어, /root/src/moduleA.ts안에 import { b } from \"./moduleB\" 같은 import 문은 \"./moduleB\"의 위치를 찾기 위해 다음과 같은 위치를 찾습니다.\n\n/root/src/moduleB.ts\n/root/src/moduleB.tsx\n/root/src/moduleB.d.ts\n/root/src/moduleB/package.json (\"types\" 항목을 지정했다면)\n/root/src/moduleB/index.ts\n/root/src/moduleB/index.tsx\n/root/src/moduleB/index.d.ts\n\nNode.js가 moduleB.js 파일을 찾고 나서, 해당하는 package.json을 찾고, index.js를 찾았다는 것을 상기해봅시다.\n비슷하게, 비-상대적 import는 Node.js 해석 로직을 따릅니다, 첫 번째로 파일을 찾고, 그러고 나서 해당하는 폴더를 찾습니다.\n그래서 /root/src/moduleA.ts 소스 파일 안에 import { b } from \"moduleB\"는 다음과 같은 조회를 합니다.\n\n/root/src/node_modules/moduleB.ts\n/root/src/node_modules/moduleB.tsx\n/root/src/node_modules/moduleB.d.ts\n/root/src/node_modules/moduleB/package.json (\"types\" 프로퍼티를 지정했다면)\n/root/src/node_modules/@types/moduleB.d.ts\n/root/src/node_modules/moduleB/index.ts\n/root/src/node_modules/moduleB/index.tsx\n/root/src/node_modules/moduleB/index.d.ts\n\n/root/node_modules/moduleB.ts\n/root/node_modules/moduleB.tsx\n/root/node_modules/moduleB.d.ts\n/root/node_modules/moduleB/package.json (\"types\" 항목을 지정했다면)\n/root/node_modules/@types/moduleB.d.ts\n/root/node_modules/moduleB/index.ts\n/root/node_modules/moduleB/index.tsx\n/root/node_modules/moduleB/index.d.ts\n\n/node_modules/moduleB.ts\n/node_modules/moduleB.tsx\n/node_modules/moduleB.d.ts\n/node_modules/moduleB/package.json (\"types\" 항목을 지정했다면)\n/node_modules/@types/moduleB.d.ts\n/node_modules/moduleB/index.ts\n/node_modules/moduleB/index.tsx\n/node_modules/moduleB/index.d.ts\n\n스텝 수 때문에 두려워하지 마세요 - TypeScript가 여전히 디렉터리를 (9)와 (17)에서 두 번 점프합니다.\nNode.js가 하는 것보다 더 복잡하지 않습니다.\n추가 모듈 해석 플래그 (Additional module resolution flags)\n프로젝트 소스 레이아웃이 출력과 일치하지 않을 때도 있습니다.\n일반적으로 일련의 빌드 스텝이 생성된 최종 출력을 만듭니다.\n.ts파일을 .js로 컴파일하고, 다른 소스 위치에서 하나의 출력 위치로 의존성을 복사하는 것을 포함합니다.\n최종 결과는 런타임의 모듈이 해당 정의를 포함하는 소스 파일과 다른 이름을 가질 수 있다는 것이다.\n혹은 최종 출력의 모듈 경로가 컴파일 타임에 해당하는 소스 파일 경로와 일치하지 않을 수 있습니다.\nTypeScript 컴파일러는 추가 플래그를 갖고 있습니다.\nThe TypeScript compiler has a set of additional flags to inform the compiler of transformations that are expected to happen to the sources to generate the final output.\nTypeScript 컴파일러는 최종 출력을 생성하기위해 소스에 발생할 것으로 예상되는 변환을 컴파일러에게 알리기 위한 추가 플래그 세트가 있습니다.\n컴파일러가 이러한 변환도 수행하지 않는 다는 것에 유의하십시오;\n정의 파일로 모듈 import를 해석하는 과정을 안내하기 위해 이러한 정보를 사용합니다.\n기본 URL (Base URL)\nbaseUrl을 사용하는 것은 모듈들이 런타임에 단일 폴더로 \"배포\"되는 AMD 모듈 로더를 사용하는 애플리케이션에서 일반적인 방법입니다.\n이 모듈들의 소스는 다른 디렉터리 안에 있을 수 있지만, 빌드 스크립트가 모두 하나로 만들 것입니다.\nbaseUrl을 설정하는 것은 컴파일러에게 어디에서 모듈을 찾을지 알려주는 것입니다.\n모든 비-상대적 이름의 모듈 import는 baseUrl에 상대적이라고 가정합니다.\nbaseUrl의 값은 다음 중 하나로 결정됩니다:\n\nbaseUrl 명령 줄 인수 값 (만약 주어진 경로가 상대적이면, 현재 디렉터리를 기준으로 계산됨)\n'tsconfig.json'안에 baseUrl 프로퍼티 값 (만약 주어진 경로가 상대적이면, 'tsconfig.json'의 위치를 기준으로 계산됨)\n\n상대적 모듈 import는 항상 가져온 파일의 상대적으로 해석되기 때문에, baseUrl을 설정하는 것에 영향을 받지 않는 점에 유의하십시오.\nbaseUrl에 대한 더 많은 문서는 RequireJS와 SystemJS 문서에서 찾으실 수 있습니다.\n경로 매핑 (Path mapping)\n가끔 모듈이 baseUrl 아래에 위치하지 않는 경우가 있습니다.\n예를 들어, \"jquery\" 모듈의 import는 런타임에 \"node_modules/jquery/dist/jquery.slim.min.js\"로 번역됩니다.\n로더는 런타임에 모듈 이름을 파일에 매핑하기 위해 매핑 구성을 사용합니다, RequireJs 문서와 SystemJS 문서를 보세요.\nTypeScript 컴파일러는 tsconfig.json 파일 안에 \"paths\" 프로퍼티를 사용한 매핑의 선언을 지원합니다.\njquery를 위한 \"paths\" 프로퍼티를 지정하는 방법에 대한 예제가 있습니다.\n{\n  \"compilerOptions\": {\n    \"baseUrl\": \".\", // \"paths\"가 있는 경우 반드시 지정되어야함.\n    \"paths\": {\n      \"jquery\": [\"node_modules/jquery/dist/jquery\"] // 이 매핑은 \"baseUrl\"에 상대적임.\n    }\n  }\n}\n\n\"paths\"가 \"baseUrl\"에 상대적으로 해석된다는 점에 주목하세요.\n\"baseUrl\"을 \".\"가 아닌 다른 값, 예 tsconfig.json의 디렉터리,으로 설정하면, 그에 따라 매핑도 바뀝니다.\n위 예제에서 \"baseUrl\": \"./src\"로 설정했기 때문에, jquery는 \"../node_modules/jquery/dist/jquery\"로 매핑됩니다.\n\"paths\"를 사용하는 것은 여러 개의 이전 위치를 포함한 정교한 매핑이 가능합니다.\n일부 모듈만 한 위치에서 사용 가능하고, 나머지는 다른 곳에 있는 프로젝트 구성을 생각해보세요.\n빌드 스텝이 한곳으로 모을 것입니다.\n프로젝트의 레이아웃은 다음과 같이 보입니다:\nprojectRoot\n├── folder1\n│   ├── file1.ts (imports 'folder1/file2' and 'folder2/file3')\n│   └── file2.ts\n├── generated\n│   ├── folder1\n│   └── folder2\n│       └── file3.ts\n└── tsconfig.json\n\ntsconfig.json는 다음과 같이 보일 것입니다:\n{\n  \"compilerOptions\": {\n    \"baseUrl\": \".\",\n    \"paths\": {\n      \"*\": [\n        \"*\",\n        \"generated/*\"\n      ]\n    }\n  }\n}\n\n이는 컴파일러에게 두 위치에서 패턴 \"*\" (i.e. 모든 값) 과 일치하는 모든 모듈 import를 알려줍니다\n\n\"*\": 같은 이름은 바뀌지 않음을 의미, 그래서  => /으로 매핑\n\"generated/*\" 접두사 \"generated\"가 추가된 모듈 이름을 의미, 그래서  => /generated/로 매핑\n\n이 로직을 따르면, 컴파일러는 다음과 같은 두 가지 import를 해석하려고 할 것입니다:\nimport 'folder1/file2':\n\n모듈 '*'은 일치하고 와일드카드가 전체 모듈 이름을 캡처함\n목록에서 첫 번째 대체 시도: '*' -> folder1/file2\n대체의 결과가 비-상대적 이름 - baseUrl과 결합 -> projectRoot/folder1/file2.ts\n파일이 존재. 완료.\n\nimport 'folder2/file3':\n\n모듈 '*'은 일치하고 와일드카드가 전체 모듈 이름을 캡처함\n목록에서 첫 번째 대체 시도: '*' -> folder2/file3\n대체의 결과가 비-상대적 이름 - baseUrl과 결합 -> projectRoot/folder2/file3.ts\n파일이 존재하지 않음, 두 번째 대체로 이동\n두 번째 대체 'generated/*' -> generated/folder2/file3\n대체의 결과가 비-상대적 이름 - baseUrl과 결합 -> projectRoot/generated/folder2/file3.ts\n파일이 존재. 완료.\n\nrootDirs 가상 디렉터리 (Virtual Directories with rootDirs)\n때때로 컴파일 타임에 여러 디렉터리의 프로젝트 소스가 모두 결합되어 단일 출력 디렉터리를 생성합니다.\n여러 소스 디렉터리가 \"가상\" 디렉터리를 생성하는 것으로 보입니다.\n'rootDirs'를 사용하면, 컴파일러에게 이 \"가상\" 디렉터리를 구성하는 roots를 알릴 수 있습니다;\n따라서 컴파일러는 이러한 \"가상\"디렉터리 내에서 상대적 모듈 import를 마치 하나의 디렉터리에 같이 병합 한 것처럼 해석할 수 있습니다.\n예를 들어 이 프로젝트 구조를 생각해보세요:\n src\n └── views\n     └── view1.ts (imports './template1')\n     └── view2.ts\n\n generated\n └── templates\n         └── views\n             └── template1.ts (imports './view2')\n\nsrc/views 안의 파일들은 UI 컨트롤을 위한 유저 코드입니다.\ngenerated/templated 안의 파일들은, 빌드의 일부로써 템플릿 생성기에 의해 자동-생성된 UI 템플릿 바인딩 코드입니다.\n빌드 스텝은 /src/view와 /generated/templates/views를 출력에서 같은 디렉터리로 복사합니다.\n런타임에서, 뷰는 템플릿이 옆에 있다고 기대할 것이기 때문에, \"./template\"처럼 상대적인 이름을 import에서 사용해야 합니다.\n컴파일러에게 이 관계를 지정하기 위해서, \"rootDirs\"를 사용합니다.\n\"rootDirs\"는 내용물이 런타임에 병합할 것으로 예상되는 roots 의 목록을 지정합니다.\n그래서 다음의 예제에서, tsconfig.json 파일은 다음과 같아야 합니다:\n{\n  \"compilerOptions\": {\n    \"rootDirs\": [\n      \"src/views\",\n      \"generated/templates/views\"\n    ]\n  }\n}\n\n컴파일러가 rootDirs 중 하나의 하위 폴더에서 상대적 모듈 import를 볼 때마다, 각 rootDirs의 엔트리에서 이 import를 찾으려고 할 것입니다.\nrootDirs의 유연함은 논리적으로 병합되는 물리적 소스 디렉터리의 목록을 지정하는데 제한되지 않습니다. 제공되는 배열은 아마 존재 여부에 관계없이 임의의 수의 ad hoc, 임의의 디렉터리 이름을 포함할 수 있습니다. 이는 컴파일러에게 조건부 포함과 프로젝트 전용 로더 플러그인과 같은 복잡한 번들링과 런타임 기능을 안전한 방법으로 캡처할 수 있게 해줍니다.\n./#{locale}/messages와 같은 상대 모듈 경로의 일부로 #{locale}와 같은 특수 경로 토큰을 보간하여 빌드 툴이 로케일 전용 번들을 자동으로 생성하는 국제화 시나리오를 고려해봅시다. 이 가상의 설정에서 툴이 지원하는 로케일을 열거하고, 추상 경로를 ./zh/messages, ./de/messages 등으로 매핑 합니다.\n각 모듈은 문자열 배열을 export 한다고 가정합니다. 예를 들어 ./zh/messages는 다음을 포함합니다:\nexport default [\n    \"您好吗\",\n    \"很高兴认识你\"\n];\n\nrootDirs를 활용하여 컴파일러에게 이 매핑에 대해 알려주어 심지어 디렉터리가 존재하지 않아도 안전하게 ./#{locale}/messages를 해석할 수 있도록 합니다. 예를 들어, 다음과 같은 tsconfig.json를 보십시오:\n{\n  \"compilerOptions\": {\n    \"rootDirs\": [\n      \"src/zh\",\n      \"src/de\",\n      \"src/#{locale}\"\n    ]\n  }\n}\n\n컴파일러는 이제 './#{locale}/messages'를 './zh/messages'로 해석하여 설계 시간 지원을 타협하지 않고 로케일에 관계없는 방법으로 개발할 수 있습니다.\n모듈 해석 추적 (Tracing module resolution)\n앞에서 논의한 바와 같이 컴파일러는 모듈을 해석할 때 현재 폴더 외부의 파일을 방문할 수 있습니다.\n이는 모듈이 해석되지 않거나 잘못된 정의로 해석된 이유를 진단할 때 어려울 수 있습니다.\n'--traceResolution'을 사용하여 컴파일러 모듈 해석 추적을 활성화하면 모듈 해석 과정 중에 발생한 작업에 대한 인사이트를 얻을 수 있습니다.\ntypescript 모듈을 사용하는 예제 애플리케이션이 있다고 해봅시다.\napp.ts는 import * as ts from \"typescript\" 같은 import가 있습니다.\n│   tsconfig.json\n├───node_modules\n│   └───typescript\n│       └───lib\n│               typescript.d.ts\n└───src\n        app.ts\n\n--traceResolution으로 컴파일러를 호출\ntsc --traceResolution\n\n다음과 같은 출력이 발생:\n======== Resolving module 'typescript' from 'src/app.ts'. ========\nModule resolution kind is not specified, using 'NodeJs'.\nLoading module 'typescript' from 'node_modules' folder.\nFile 'src/node_modules/typescript.ts' does not exist.\nFile 'src/node_modules/typescript.tsx' does not exist.\nFile 'src/node_modules/typescript.d.ts' does not exist.\nFile 'src/node_modules/typescript/package.json' does not exist.\nFile 'node_modules/typescript.ts' does not exist.\nFile 'node_modules/typescript.tsx' does not exist.\nFile 'node_modules/typescript.d.ts' does not exist.\nFound 'package.json' at 'node_modules/typescript/package.json'.\n'package.json' has 'types' field './lib/typescript.d.ts' that references 'node_modules/typescript/lib/typescript.d.ts'.\nFile 'node_modules/typescript/lib/typescript.d.ts' exist - use it as a module resolution result.\n======== Module name 'typescript' was successfully resolved to 'node_modules/typescript/lib/typescript.d.ts'. ========\n\n주의사항 (Things to look out for)\n\nimport의 이름과 위치\n\n======== 'src/app.ts' 에서 'typesciprt' 모듈 해석. ========\n\n\n컴파일러가 따르는 전략\n\n모듈 해석 종류가 지정되지 않으면, 'NodeJs 사용.\n\n\nnpm 패키지에서 types 로딩\n\n'package.json'은 'node_modules/typescript/lib/typescript.d.ts'를 참조하는 'types' 필드 './lib/typescript.d.ts'가 있습니다.\n\n\n최종 결과\n\n======== 모듈 이름 'typescript'는 'node_modules/typescript/lib/typescript.d.ts'로 성공적으로 해석 되었습니다. ========\n\n\n\n--noResolve 사용하기 (Using --noResolve)\n일반적으로 컴파일러는 컴파일 과정을 시작하기 전에 모든 모듈 import를 해석하려고 합니다.\n파일의 import를 성공적으로 해석할 때마다, 파일은 나중에 컴파일러가 처리할 파일 세트에 추가됩니다.\n--noResolve 컴파일러 옵션은 명령 줄에 전달하지 않은 파일은 컴파일에 \"추가\" 하지 않도록 지시합니다.\n여전히 파일에 모듈을 해석하려고 하지만, 파일이 지정되지 않았으면, 그 파일은 포함하지 않습니다.\n예를 들어:\napp.ts\nimport * as A from \"moduleA\" // 성공, 'moduleA'가 명령줄로 전달됨\nimport * as B from \"moduleB\" // Error TS2307: Cannot find module 'moduleB.\n\ntsc app.ts moduleA.ts --noResolve\n\n--noResolve를 사용한 app.ts의 컴파일은 다음과 같은 결과가 나옵니다:\n\n명령 줄로 전달했기 때문에 moduleA는 정확하게 찾음.\n전달하지 않았기 때문에 moduleB를 찾는데 실패함.\n\n공통 질문 (Common Questions)\n제외 목록에 있는 모듈을 여전히 컴파일러가 선택하는 이유는 무엇인가? (Why does a module in the exclude list still get picked up by the compiler?)\ntsconfig.json은 폴더를 \"프로젝트\"로 바꿉니다.\n\"exclude\" 나 \"files\" 엔트리를 지정하지 않으면, tsconfig.json를 포함하는 폴더 안의 모든 파일과 모든 하위-디렉터리가 컴파일에 포함됩니다.\n만약 일부 파일을 제외하고 싶으면 \"exclude\"를 사용하고, 컴파일러가 찾도록 하게 하는 대신 모든 파일을 지정하고 싶으면, \"files\"를 사용하십시오.\ntsconfig.json의 자동 포함입니다.\n위에서 논의한 내장 모듈 해석이 아닙니다.\n컴파일러는 파일을 모듈 import 대상으로 식별한 경우, 이전 단계에서 제외되었는지에 관계없이 컴파일에 포함하게 됩니다.\n그래서 컴파일에 파일은 제외하기 위해서는, 그 파일을 제외하고 그 파일에 import나 ///  지시문이 있는 모든 파일을 제외해야 합니다.\n"},"pages/Declaration Merging.html":{"url":"pages/Declaration Merging.html","title":"선언 병합","keywords":"","body":"소개 (Introduction)\nTypeScript의 독특한 개념들 중 일부는 타입 레벨에서 JavaScript 객체의 형태를 설명합니다.\n그중 TypeScript만의 특별한 예로 '선언 병합' 개념이 있습니다.\n이 개념을 이해한다면 기존의 JavaScript와 작업을 할 때 이점이 많아집니다.\n또한 이 개념은 고급 추상화 개념으로의 문을 열어줄 것입니다.\n본론으로 돌아가서, \"선언 병합\"은 컴파일러가 같은 이름으로 선언된 두 개의 개별적인 선언을 하나의 정의로 병합하는 것을 뜻합니다.\n이 병합된 정의는 원래 두 선언 각각의 기능을 모두 갖게 됩니다.\n병합할 선언이 몇 개든 상관없습니다; 이 개념은 단지 두 개의 선언만 합치도록 제한하지 않습니다.\n기본 사용법 (Basic Concepts)\nTypeScript에서 선언은 네임스페이스, 타입, 값 중 한 종류 이상의 엔티티를 생성합니다.\n네임스페이스-생성 선언은 점으로 구분된 표기법을 사용하여 접근할 이름을 가진 네임스페이스를 생성합니다.\n타입-생성 선언은 선언된 형태로 표시되며 지정된 이름에 바인딩 된 타입을 생성합니다.\n마지막으로 값-생성 선언은 출력된 JavaScript에서 확인할 수 있는 값을 생성합니다.\n\n\n\n선언 타입\n네임스페이스\n타입\n값\n\n\n\n\n네임스페이스\nX\n\nX\n\n\n클래스\n\nX\nX\n\n\n열거형\n\nX\nX\n\n\n인터페이스\n\nX\n\n\n\n타입 별칭\n\nX\n\n\n\n함수\n\n\nX\n\n\n변수\n\n\nX\n\n\n\n각 선언으로 생성된 결과물을 이해하면, 선언 병합을 할 때 병합된 결과물을 이해하는 데에 도움이 됩니다.\n인터페이스 병합 (Merging Interfaces)\n가장 일반적이고 간단한 선언 병합 유형은 인터페이스 병합입니다.\n가장 기본적인 수준에서, 병합은 각 선언의 멤버를 같은 이름의 인터페이스에 기계적으로 결합합니다.\ninterface Box {\n    height: number;\n    width: number;\n}\n\ninterface Box {\n    scale: number;\n}\n\nlet box: Box = {height: 5, width: 6, scale: 10};\n\n각 인터페이스의 비-함수 멤버는 고유해야 합니다.\n만약 고유하지 않다면, 모두 같은 타입이어야 합니다.\n인터페이스가 같은 이름이지만 다른 타입을 가진 비-함수 멤버가 있을 경우, 컴파일러는 오류를 일으킵니다.\n함수 멤버의 경우, 이름이 같을 경우 동일한 함수에 대한 오버로드하는 것으로 처리합니다.\n또한 A 인터페이스와 나중의 A 인터페이스를 병합하는 경우, 두 번째 인터페이스가 더 높은 우선순위를 갖게 됩니다.\n이 말은, 예를 들어:\ninterface Cloner {\n    clone(animal: Animal): Animal;\n}\n\ninterface Cloner {\n    clone(animal: Sheep): Sheep;\n}\n\ninterface Cloner {\n    clone(animal: Dog): Dog;\n    clone(animal: Cat): Cat;\n}\n\n위의 세 인터페이스는 병합되어 다음과 같이 하나의 새로운 선언을 생성합니다:\ninterface Cloner {\n    clone(animal: Dog): Dog;\n    clone(animal: Cat): Cat;\n    clone(animal: Sheep): Sheep;\n    clone(animal: Animal): Animal;\n}\n\n각 그룹의 요소는 동일한 순서를 유지하지만, 그룹 자체는 나중에 병합되어 오버로드 될수록 첫 번째에 위치하는 것에 유의하세요.\n그러나 이 규칙엔 특수 시그니처라는 예외가 존재합니다.\n시그니처에 단일 문자열 리터럴 타입(예: 문자열 리터럴의 유니언이 아닌 경우)인 매개변수가 있을 경우, 시그니처는 병합된 오버로드 목록의 맨 위로 올라오게 됩니다.\n예를 들어, 아래의 인터페이스들이 병합됩니다:\ninterface Document {\n    createElement(tagName: any): Element;\n}\ninterface Document {\n    createElement(tagName: \"div\"): HTMLDivElement;\n    createElement(tagName: \"span\"): HTMLSpanElement;\n}\ninterface Document {\n    createElement(tagName: string): HTMLElement;\n    createElement(tagName: \"canvas\"): HTMLCanvasElement;\n}\n\nDocument의 병합된 선언은 다음과 같이 생성합니다:\ninterface Document {\n    createElement(tagName: \"canvas\"): HTMLCanvasElement;\n    createElement(tagName: \"div\"): HTMLDivElement;\n    createElement(tagName: \"span\"): HTMLSpanElement;\n    createElement(tagName: string): HTMLElement;\n    createElement(tagName: any): Element;\n}\n\n네임스페이스 병합 (Merging Namespaces)\n인터페이스와 마찬가지로, 같은 이름을 가진 네임스페이스도 멤버를 병합합니다.\n네임스페이스는 네임스페이스와 값을 둘 다 생성하기 때문에, 이들이 어떻게 병합하는지 이해해야 합니다.\n네임스페이스를 병합하기 위해 각 네임스페이스에 선언된 내보낸 인터페이스로부터 타입 정의가 병합되며, 내부에 병합된 인터페이스 정의들이 있는 단일 네임스페이스를 형성됩니다.\n네임스페이스 값을 병합하려면, 각 선언 위치에서 이미 지정된 이름의 네임스페이스가 있을 경우, 기존 네임스페이스에 두 번째 네임스페이스의 내보낸 멤버를 첫 번째에 추가하여 네임스페이스 값을 확장됩니다.\n이 예제에서 Animals의 선언 병합:\nnamespace Animals {\n    export class Zebra { }\n}\n\nnamespace Animals {\n    export interface Legged { numberOfLegs: number; }\n    export class Dog { }\n}\n\n다음과 같습니다:\nnamespace Animals {\n    export interface Legged { numberOfLegs: number; }\n\n    export class Zebra { }\n    export class Dog { }\n}\n\n이러한 네임스페이스 병합의 모델은 좋은 출발점이지만, 우리는 export 되지 않은 멤버에 대해 무슨 일이 일어나는지 이해할 필요가 있습니다.\nexport 되지 않은 멤버는 원래의(병합되지 않은) 네임스페이스에서만 볼 수 있습니다. 이는 병합된 후에 다른 선언으로부터 합쳐진 멤버는 export 되지 않은 멤버를 볼 수 없다는 것을 의미합니다.\n이 예제에서 더 명확하게 확인할 수 있습니다:\nnamespace Animal {\n    let haveMuscles = true;\n\n    export function animalsHaveMuscles() {\n        return haveMuscles;\n    }\n}\n\nnamespace Animal {\n    export function doAnimalsHaveMuscles() {\n        return haveMuscles;  // 오류, haveMuscles는 이곳에서 액세스 할 수 없습니다.\n    }\n}\n\nhaveMuscles이 export 되지 않아서, 동일하게 병합되지 않은 네임스페이스를 공유하는 animalsHaveMuscles 함수만 이 심벌을 볼 수 있습니다.\ndoAnimalsHaveMuscles 함수가 병합된 Animal의 멤버일지라도, 내보내지 않은 멤버는 볼 수 없습니다.\n클래스, 함수, 열거형과 네임스페이스 병합 (Merging Namespaces with Classes, Functions, and Enums)\n네임스페이스는 다른 타입의 선언과 병합할 수 있을 정도로 유연합니다.\n이를 위해선, 네임스페이스의 선언은 병합할 선언을 따라야 합니다. 결과 선언에는 두 타입의 프로퍼티를 모두 갖습니다.\nTypeScript는 이를 통해 JavaScript 및 기타 프로그래밍 언어의 패턴을 모델링 합니다.\n네임스페이스와 클래스 병합 (Merging Namespaces with Classes)\n이 부분에서는 내부 클래스를 설명하는 방법을 제공합니다.\nclass Album {\n    label: Album.AlbumLabel;\n}\nnamespace Album {\n    export class AlbumLabel { }\n}\n\n병합된 멤버의 가시성 규칙은 '네임스페이스 병합' 섹션에서 설명한 것과 같으므로, AlbumLabel 클래스를 export 해야 병합된 클래스를 볼 수 있습니다.\n최종 결과물은 다른 클래스 내에서 관리되는 클래스입니다.\n또한 네임스페이스를 사용하여 기존 클래스에 더 많은 정적 멤버를 추가할 수도 있습니다.\n내부 클래스 패턴 이외에도, JavaScript에서 함수를 생성한 후 프로퍼티를 추가하여 함수를 확장하는 것에도 익숙할 것입니다.\nTypeScript는 선언 병합을 통해 타입을 안전하게 보존하며 정의할 수 있습니다.\nfunction buildLabel(name: string): string {\n    return buildLabel.prefix + name + buildLabel.suffix;\n}\n\nnamespace buildLabel {\n    export let suffix = \"\";\n    export let prefix = \"Hello, \";\n}\n\nconsole.log(buildLabel(\"Sam Smith\"));\n\n마찬가지로, 네임스페이스를 정적 멤버의 열거형을 확장할 수 있습니다:\nenum Color {\n    red = 1,\n    green = 2,\n    blue = 4\n}\n\nnamespace Color {\n    export function mixColor(colorName: string) {\n        if (colorName == \"yellow\") {\n            return Color.red + Color.green;\n        }\n        else if (colorName == \"white\") {\n            return Color.red + Color.green + Color.blue;\n        }\n        else if (colorName == \"magenta\") {\n            return Color.red + Color.blue;\n        }\n        else if (colorName == \"cyan\") {\n            return Color.green + Color.blue;\n        }\n    }\n}\n\n허용되지 않는 병합 (Disallowed Merges)\nTypeScript에서 모든 병합이 허용되는 것은 아닙니다.\n현재로선, 클래스는 다른 클래스 혹은 변수와 병합할 수 없습니다.\n클래스 병합을 대체하려면, TypeScript의 믹스인 섹션을 참고하세요.\n모듈 보강 (Module Augmentation)\nJavaScript는 모듈 병합을 지원하지 않지만, 기존 객체를 가져와 업데이트하여 패치 할 수 있습니다.\n아래의 장난감 Observable 예시를 살펴보겠습니다:\n// observable.ts\nexport class Observable {\n    // ... 구현은 여러분의 몫으로 남겨놓겠습니다 ...\n}\n\n// map.ts\nimport { Observable } from \"./observable\";\nObservable.prototype.map = function (f) {\n    // ... 여러분을 위한 또 다른 숙제\n}\n\n이는 TypeScript에서 잘 동작하지만, 컴파일러는 Observable.prototype.map에 대해 알지 못합니다.\n모듈 보강을 통해 컴파일러에게 정보를 알려줄 수 있습니다:\n// observable.ts\nexport class Observable {\n    // ... 구현은 여러분의 몫으로 남겨놓겠습니다 ...\n}\n\n// map.ts\nimport { Observable } from \"./observable\";\ndeclare module \"./observable\" {\n    interface Observable {\n        map(f: (x: T) => U): Observable;\n    }\n}\nObservable.prototype.map = function (f) {\n    // ... 여러분을 위한 또 다른 숙제\n}\n\n\n// consumer.ts\nimport { Observable } from \"./observable\";\nimport \"./map\";\nlet o: Observable;\no.map(x => x.toFixed());\n\n모듈 이름은 import/export의 모듈 지정자와 같은 방법으로 해석됩니다.\n자세한 내용은 모듈을 참고하세요.\n그 다음 보강된 선언은 마치 원본과 같은 파일에서 선언된 것처럼 병합됩니다.\n그러나, 두 가지 제한 사항을 명심하세요:\n\n보강에 새로운 최상위 선언을 할 수 없습니다 -- 기존 선언에 대한 패치만 가능합니다.\ndefault export 는 보강할 수 없으며, 이름을 갖는 export 만 보강할 수 있습니다.(해당 이름으로 확장시켜야 하며, default는 예약어입니다 - 자세한 내용은 #14080을 참고하세요)\n\n전역 보강 (Global augmentation)\n모듈 내부에서 전역 범위에 선언을 추가할 수도 있습니다:\n// observable.ts\nexport class Observable {\n    // ... 여전히 구현해놓지 않았습니다 ...\n}\n\ndeclare global {\n    interface Array {\n        toObservable(): Observable;\n    }\n}\n\nArray.prototype.toObservable = function () {\n    // ...\n}\n\n전역 보강 또한 모듈 보강과 동일한 제한 사항을 갖습니다.\n"},"pages/JSX.html":{"url":"pages/JSX.html","title":"JSX","keywords":"","body":"목차 (Table of contents)\n소개 (Introduction)\n기본 사용법 (Basic usage)\nas 연산자 (The as operator)\n타입 검사 (Type Checking)\n\n내장 요소 (Intrinsic elements)\n값-기반 요소 (Value-based elements)\n함수형 컴포넌트 (Function Component)\n클래스형 컴포넌트 (Class Component)\n속성 타입 검사 (Attribute type checking)\n자식 타입 검사 (Children Type Checking)\n\nJSX 결과 타입 (The JSX result type)\n표현식 포함하기 (Embedding Expressions)\n리액트와 통합하기 (React integration)\n팩토리 함수 (Factory Functions)\n소개 (Introduction)\n↥ 위로\nJSX는 내장형 XML 같은 구문입니다.\n변환의 의미는 구현에 따라 다르지만 유효한 JavaScript로 변환되어야 합니다.\nJSX는 React로 큰 인기를 얻었지만, 이후 다른 구현도 등장했습니다.\nTypeScript는 임베딩, 타입 검사, JSX를 JavaScript로 직접 컴파일하는 것을 지원합니다.\n기본 사용법 (Basic usage)\n↥ 위로\nJSX를 사용하려면 다음 두 가지 작업을 해야 합니다.\n\n파일 이름을 .tsx 확장자로 지정합니다.\njsx 옵션을 활성화합니다.\n\nTypeScript는 preserve, react 및 react-native라는 세 가지의 JSX 모드와 함께 제공됩니다.\n이 모드들은 방출 단계에서만 영향을 미치며, 타입 검사에는 영향을 받지 않습니다.\npreserve 모드는 다른 변환 단계(예: Babel)에 사용하도록 결과물의 일부를 유지합니다.\n또한 결과물은 .jsx 파일 확장자를 갖습니다.\nreact 모드는 React.createElement를 생성하여, 사용하기 전에 JSX 변환이 필요하지 않으며, 결과물은 .js 확장자를 갖게 됩니다.\nreact-native 모드는 JSX를 유지한다는 점은 preserve 모드와 동일하지만, 결과물은 .js 확장자를 갖게 된다는 점이 다릅니다.\n\n\n\n모드\n입력\n결과\n결과 파일 확장자\n\n\n\n\npreserve\n\n\n.jsx\n\n\nreact\n\nReact.createElement(\"div\")\n.js\n\n\nreact-native\n\n\n.js\n\n\n\n--jsx 명령줄 플래그 또는 tsconfig.json 파일의 해당 옵션을 사용하여 모드를 지정할 수 있습니다.\n\n*참고: React JSX를 생성할 때 --jsxFactory 옵션으로  사용할 JSX 팩토리(JSX factory) 함수를 지정할 수 있습니다 (기본값은 React.createElement)\n\nas 연산자 (The as operator)\n↥ 위로\n타입 단언(type assertion)을 어떻게 작성하는지 떠올려 볼까요:\nvar foo = bar;\n\n위 코드는 변수 bar가 foo 타입이라는 것을 단언합니다.\nTypeScript는 꺾쇠 괄호를 사용해 타입을 단언하기 때문에, JSX 구문과 함께 사용할 경우 특정 문법 해석에 문제가 될 수도 있습니다. 결과적으로 TypeScript는 .tsx 파일에서 화살 괄호를 통한 타입 단언을 허용하지 않습니다.\n위의 구문은 .tsx 파일에서 사용할 수 없으므로, as라는 대체 연산자를 통해 타입 단언을 해야 합니다.\n위의 예시는 as 연산자로 쉽게 다시 작성할 수 있습니다.\nvar foo = bar as foo;\n\nas 연산자는 .ts와 .tsx 파일 모두 사용할 수 있으며, 꺾쇠 괄호 형식의 단언과 동일하게 동작합니다.\n타입 검사 (Type Checking)\n↥ 위로\nJSX의 타입 검사를 이해하기 위해선, 먼저 내장 요소와 값-기반 요소의 차이점에 대해 알아야 합니다.\nJSX 표현식 에서 expr은 환경에 내장된 요소(예: DOM 환경의 div 또는 span) 혹은 사용자가 만든 사용자 정의 컴포넌트를 참조할 것입니다.\n이는 다음과 같은 두 가지 이유로 중요합니다:\n\n리액트에서 내장 요소는 React.createElement(\"div\")과 같은 문자열로 생성되는 반면, 사용자가 만든 컴포넌트는 React.createElement(\"MyComponent\")가 아닙니다.\nJSX 요소에 전달되는 속성의 타입은 다르게 조회되어야 합니다.\n내장 요소의 속성은 내재적으로 알고 있어야 하지만, 컴포넌트는 각각 자신의 속성 집합을 지정하려고 합니다.\n\nTypeScript는 React와 동일한 규칙을 사용하여 구별합니다.\n내장 요소는 항상 소문자로 시작하고 값-기반 요소는 항상 대문자로 시작합니다.\n내장 요소 (Intrinsic elements)\n↥ 위로\n내장 요소는 특수 인터페이스 JSX.IntrinsicElements에서 조회됩니다.\n기본적으로 이 인터페이스가 지정되지 않으면 그대로 진행되어 내장 요소 타입은 검사되지 않습니다.\n그러나 이 인터페이스가 있는 경우, 내장 요소의 이름은 JSX.IntrinsicElements 인터페이스의 프로퍼티로 조회됩니다.\n예를 들어:\ndeclare namespace JSX {\n    interface IntrinsicElements {\n        foo: any\n    }\n}\n\n; // 성공\n; // 오류\n\n위의 예제에서 는 잘 동작하지만, 는 JSX.IntrinsicElements에 지정되지 않았기 때문에 오류를 일으킵니다.\n\n참고: 다음과 같이 JSX.IntrinsicElements에 catch-all 문자열 인덱서를 지정할 수도 있습니다.\n\ndeclare namespace JSX {\n    interface IntrinsicElements {\n        [elemName: string]: any;\n    }\n}\n\n값-기반 요소 (Value-based elements)\n↥ 위로\n값-기반 요소는 해당 스코프에 있는 식별자로 간단하게 조회됩니다.\nimport MyComponent from \"./myComponent\";\n\n; // 성공\n; // 오류\n\n값-기반 요소를 정의하는데엔 다음의 두 가지 방법이 있습니다:\n\n함수형 컴포넌트 (FC)\n클래스형 컴포넌트\n\n이 두 가지 유형의 값-기반 요소는 JSX 표현식에서 서로 구별할 수 없으므로, TS는 과부하 해결을 사용하여 먼저 함수형 컴포넌트 표현식으로 해석합니다. 이 과정이 성공적으로 진행되면, TS는 이 선언을 표현식으로 해석합니다. 함수형 컴포넌트로 해석되지 않는다면, TS는 클래스형 컴포넌트로 해석을 시도합니다. 이 과정도 실패할 경우, TS는 오류를 보고합니다.\n함수형 컴포넌트 (Function Component)\n↥ 위로\n이름에서 알 수 있듯, 컴포넌트는 첫 번째 인수가 props 객체인 JavaScript 함수로 정의됩니다.\nTS는 컴포넌트의 반환 타입이 JSX.Element에 할당 가능하도록 요구합니다.\ninterface FooProp {\n  name: string;\n  X: number;\n  Y: number;\n}\n\ndeclare function AnotherComponent(prop: {name: string});\nfunction ComponentFoo(prop: FooProp) {\n  return ;\n}\n\nconst Button = (prop: {value: string}, context: { color: string }) => \n\n함수형 컴포넌트는 JavaScript 함수이므로, 함수 오버로드 또한 사용 가능합니다:\ninterface ClickableProps {\n  children: JSX.Element[] | JSX.Element\n}\n\ninterface HomeProps extends ClickableProps {\n  home: JSX.Element;\n}\n\ninterface SideProps extends ClickableProps {\n  side: JSX.Element | string;\n}\n\nfunction MainButton(prop: HomeProps): JSX.Element;\nfunction MainButton(prop: SideProps): JSX.Element {\n  ...\n}\n\n\n참고: 함수형 컴포넌트는 이전에 무상태 함수형 컴포넌트(SFC)로 알려져 있습니다. 하지만 최근 버전의 리액트에선 더 이상 함수형 컴포넌트를 무상태로 취급하지 않으며, SFC 타입과 그 별칭인 StatelessComponent은 더 이상 사용되지 않습니다.\n\n클래스형 컴포넌트 (Class Component)\n↥ 위로\n클래스형 컴포넌트의 타입을 정의하는 것은 가능합니다.\n이를 위해선 요소 클래스 타입 과 요소 인스턴스 타입 이라는 새로운 용어를 이해해야 합니다.\n에서, 요소 클래스 타입 은 Expr의 타입입니다.\n위의 예시에서 MyComponent가 ES6 클래스라면 이 클래스 타입은 클래스 생성자이고 전역입니다.\nMyComponent가 팩토리 함수라면, 클래스 타입은 해당 함수입니다.\n클래스 타입이 결정되면, 인스턴스 타입은 클래스 타입의 생성자 혹은 호출 시그니처(있는 것 중 어느 쪽으로든)에 의한 반환 타입을 결합하여 결정됩니다.\n따라서 ES6 클래스의 경우, 인스턴스 타입은 해당 클래스의 인스턴스 타입이 되고, 팩토리 함수의 경우엔 해당 함수로부터 반환된 값의 타입이 됩니다.\nclass MyComponent {\n  render() {}\n}\n\n// 생성자 시그니처 사용\nvar myComponent = new MyComponent();\n\n// 요소 클래스 타입 => MyComponent\n// 요소 인스턴스 타입 => { render: () => void }\n\nfunction MyFactoryFunction() {\n  return {\n    render: () => {\n    }\n  }\n}\n\n// 호출 시그니처 사용\nvar myComponent = MyFactoryFunction();\n\n// 요소 클래스 타입 => MyFactoryFunction\n// 요소 인스턴스 타입 => { render: () => void }\n\n흥미롭게도 요소 인스턴스 타입은 JSX.ElementClass에 할당 가능해야 하며, 그렇지 않을 경우 오류를 일으킵니다.\n기본적으로 JSX.ElementClass는 {}이지만, 적절한 인터페이스에 적합한 타입으로만 JSX를 사용하도록 제한할 수 있습니다.\ndeclare namespace JSX {\n  interface ElementClass {\n    render: any;\n  }\n}\n\nclass MyComponent {\n  render() {}\n}\nfunction MyFactoryFunction() {\n  return { render: () => {} }\n}\n\n; // 성공\n; // 성공\n\nclass NotAValidComponent {}\nfunction NotAValidFactoryFunction() {\n  return {};\n}\n\n; // 오류\n; // 오류\n\n속성 타입 검사 (Attribute type checking)\n↥ 위로\n속성 타입 검사를 위해선 첫 번째로 요소 속성 타입 을 결정해야 합니다.\n이는 내장 요소와 값-기반 요소 간에 약간 다른 점이 있습니다.\n내장 요소의 경우, 요소 속성 타입은 JSX.IntrinsicElements의 프로퍼티 타입과 동일합니다.\ndeclare namespace JSX {\n  interface IntrinsicElements {\n    foo: { bar?: boolean }\n  }\n}\n\n// 'foo'의 요소 속성 타입은 '{bar?: boolean}'\n;\n\n값-기반 요소의 경우엔 조금 더 복잡합니다.\n이전에 요소 인스턴스 타입 의 프로퍼티 타입에 따라 결정됩니다.\n사용할 프로퍼티는 JSX.ElementAttributesProperty에 따라 결정됩니다.\n이는 단일 프로퍼티로 선언되어야 합니다.\n이후 해당 프로퍼티 이름을 사용합니다.\nTypeScript 2.8 부터 JSX.ElementAttributesProperty가 제공되지 않으면, 클래스 요소의 생성자 또는 함수형 컴포넌트의 첫 번째 매개변수 타입을 대신 사용할 수 있습니다.\ndeclare namespace JSX {\n  interface ElementAttributesProperty {\n    props; // 사용할 프로퍼티 이름을 지정\n  }\n}\n\nclass MyComponent {\n  // 요소 인스턴스 타입의 프로퍼티를 지정\n  props: {\n    foo?: string;\n  }\n}\n\n// 'MyComponent'의 요소 속성 타입은 '{foo?: string}'\n\n\n요소 속성 타입은 JSX에서 속성 타입을 확인하는데 사용됩니다.\n선택적 혹은 필수적인 프로퍼티들이 지원됩니다.\ndeclare namespace JSX {\n  interface IntrinsicElements {\n    foo: { requiredProp: string; optionalProp?: number }\n  }\n}\n\n; // 성공\n; // 성공\n; // 오류, requiredProp이 누락됨\n; // 오류, requiredProp은 문자열이어야 함\n; // 오류, unknownProp은 존재하지 않음\n; // 성공, 'some-unknown-prop'은 유효한 식별자가 아니기 때문에\n\n\n참고: 만약 속성 이름이 유효한 JavaScript 식별자(data-* 속성 등)가 아닌 경우, 해당 이름을 요소 속성 타입에서 찾을 수 없어도 오류로 간주하지 않습니다.\n\n추가적으로, JSX.IntrinsicAttributes 인터페이스는 일반적으로 컴포넌트의 props나 인수로 사용되지 않는 JSX 프레임워크를 위한 추가적인 프로퍼티를 지정할 수 있습니다. - 예를 들면 React의 key. 더 나아가서, JSX.IntrinsicClassAttributes 제네릭 타입을 사용하여 클래스형 컴포넌트에 대해 동일한 종류의 추가 속성을 지정할 수 있습니다 (함수형 컴포넌트 제외하고). 이 유형에서, 제네릭의 매개변수는 클래스 인스턴스 타입에 해당합니다. React의 경우, 이는 Ref 타입의 ref 속성을 허용하는 데에 쓰입니다. 일반적으로는, JSX 프레임워크 사용자가 모든 태그에 특정 속성을 제공할 필요가 없다면, 이런 인터페이스의 모든 프로퍼티는 선택적이어야 합니다.\n스프레드 연산자 또한 동작합니다:\nvar props = { requiredProp: \"bar\" };\n; // 성공\n\nvar badProps = {};\n; // 오류\n\n자식 타입 검사 (Children Type Checking)\n↥ 위로\nTypeScript 2.3부터, TS는 자식 의 타입 검사를 도입했습니다. 자식 은 자식 JSX 표현식 을 속성에 삽입하는 요소 속성 타입의 특수한 프로퍼티입니다.\nTS는 JSX.ElementAttributesProperty를 사용해 props 를 결정하는 것과 유사하게, JSX.ElementChildrenAttribute를 사용해 해당 props 내의 자식 의 이름을 결정합니다.\nJSX.ElementChildrenAttribute는 단일 프로퍼티로 선언되어야 합니다.\ndeclare namespace JSX {\n  interface ElementChildrenAttribute {\n    children: {};  // 사용할 자식의 이름을 지정\n  }\n}\n\n\n  Hello\n;\n\n\n  Hello\n  World\n;\n\nconst CustomComp = (props) => {props.children}\n\n  Hello World\n  {\"This is just a JS expression...\" + 1000}\n\n\n다른 속성처럼 자식 의 타입도 지정할 수 있습니다. 예를 들어 React 타이핑 을 사용하는 경우 기본 타입을 오버라이드 할 것입니다.\ninterface PropsType {\n  children: JSX.Element\n  name: string\n}\n\nclass Component extends React.Component {\n  render() {\n    return (\n      \n        {this.props.children}\n      \n    )\n  }\n}\n\n// 성공\n\n  Hello World\n\n\n// 오류 : 자식은 JSX.Element의 배열이 아닌 JSX.Element 타입입니다.\n\n  Hello World\n  Hello World\n\n\n// 오류 : 자식은 JSX.Element의 배열이나 문자열이 아닌 JSX.Element 타입입니다.\n\n  Hello\n  World\n\n\nJSX 결과 타입 (The JSX result type)\n↥ 위로\n기본적으로 JSX 표현식의 결과물은 any 타입입니다.\nJSX.Element 인터페이스를 수정하여 특정한 타입을 지정할 수 있습니다.\n그러나 이 인터페이스에서는 JSX의 요소, 속성, 자식에 대한 정보를 검색할 수 없습니다.\n이 인터페이스는 블랙박스입니다.\n표현식 포함하기 (Embedding Expressions)\n↥ 위로\nJSX는 중괄호({ })로 표현식을 감싸 태그 사이에 표현식 사용을 허용합니다.\nvar a = \n  {[\"foo\", \"bar\"].map(i => {i / 2})}\n\n\n위의 코드는 문자열을 숫자로 나눌 수 없으므로 오류를 일으킵니다.\npreserve 옵션을 사용할 때, 결과는 다음과 같습니다:\nvar a = \n  {[\"foo\", \"bar\"].map(function (i) { return {i / 2}; })}\n\n\n리액트와 통합하기 (React integration)\n↥ 위로\n리액트에서 JSX를 사용하기 위해선 React 타이핑을 사용해야 합니다.\n이는 리액트를 사용할 수 있도록 JSX 네임스페이스를 적절하게 정의합니다.\n/// \n\ninterface Props {\n  foo: string;\n}\n\nclass MyComponent extends React.Component {\n  render() {\n    return {this.props.foo}\n  }\n}\n\n; // 성공\n; // 오류\n\n팩토리 함수 (Factory Functions)\n↥ 위로\njsx: react 컴파일러 옵션에서 사용하는 팩토리 함수는 설정이 가능합니다. 이는 jsxFactory 명령 줄 옵션을 사용하거나 인라인 @jsx 주석을 사용하여 파일별로 설정할 수 있습니다. 예를 들어 jsxFactory에 createElement를 설정했다면, 는 React.createElement(\"div\") 대신 createElement(\"div\")으로 생성될 것입니다.\n주석 pragma 버전은 다음과 같이 사용할 수 있습니다 (TypeScript 2.8 기준):\nimport preact = require(\"preact\");\n/* @jsx preact.h */\nconst x = ;\n\n이는 다음처럼 생성됩니다:\nconst preact = require(\"preact\");\nconst x = preact.h(\"div\", null);\n\n선택된 팩토리는 전역 네임스페이스로 돌아가기 전에 JSX 네임스페이스(타입 검사를 위한 정보)에도 영향을 미칩니다. 팩토리가 React.createElement(기본값)로 정의되어 있다면, 컴파일러는 전역 JSX를 검사하기 전에 React.JSX를 먼저 검사할 것입니다. 팩토리가 h로 정의되어 있다면, 컴파일러는 전역 JSX를 검사하기 전에 h.JSX를 검사할 것입니다.\n"},"pages/Decorators.html":{"url":"pages/Decorators.html","title":"데코레이터","keywords":"","body":"소개 (Introduction)\nTypeScript 및 ES6에 클래스가 도입됨에 따라, 클래스 및 클래스 멤버에 어노테이션을 달거나 수정하기 위해 추가 기능이 필요한 특정 시나리오가 있습니다.\n데코레이터는 클래스 선언과 멤버에 어노테이션과 메타-프로그래밍 구문을 추가할 수 있는 방법을 제공합니다.\n데코레이터는 JavaScript에 대한 2단계 제안이며 TypeScript의 실험적 기능으로 이용 가능합니다.\n\n참고  데코레이터는 향후 릴리스에서 변경될 수 있는 실험적인 기능입니다.\n\n데코레이터에 대한 실험적 지원을 활성화하려면 명령줄 또는 tsconfig.json에서 experimentDecorators 컴파일러 옵션을 활성화해야합니다:\n명령줄 (Command Line):\ntsc --target ES5 --experimentalDecorators\n\ntsconfig.json:\n{\n    \"compilerOptions\": {\n        \"target\": \"ES5\",\n        \"experimentalDecorators\": true\n    }\n}\n\n데코레이터 (Decorators)\n데코레이터는 클래스 선언, 메서드, 접근자, 프로퍼티 또는 매개 변수에 첨부할 수 있는 특수한 종류의 선언입니다.\n데코레이터는 @expression 형식을 사용합니다. 여기서 expression은 데코레이팅 된 선언에 대한 정보와 함께 런타임에 호출되는 함수여야 합니다.\n예를 들어, 데코레이터 @sealed를 사용하면 다음과 같이 sealed 함수를 작성할 수 있습니다.\nfunction sealed(target) {\n    // 'target' 변수와 함께 무언가를 수행합니다.\n}\n\n\n참고  아래 데코레이터 클래스에서 더 자세한 데코레이터 예제를 볼 수 있습니다.\n\n데코레이터 팩토리 (Decorator Factories)\n데코레이터가 선언에 적용되는 방식을 원하는 대로 바꾸고 싶다면 데코레이터 팩토리를 작성할 수 있습니다. 데코레이터 팩토리는 단순히 데코레이터가 런타임에 호출할 표현식을 반환하는 함수입니다.\n다음과 같은 방식으로 데코레이터 팩토리를 작성할 수 있습니다.\nfunction color(value: string) { // 데코레이터 팩토리\n    return function (target) { // 데코레이터\n        // 'target'과 'value' 변수를 가지고 무언가를 수행합니다.\n    }\n}\n\n\n참고  아래 메서드 데코레이터에서 데코레이터 팩토리에 대한 자세한 예를 볼 수 있습니다.\n\n데코레이터 합성 (Decorator Composition)\n다음 예제와 같이 선언에 여러 데코레이터를 적용할 수 있습니다.\n\n단일 행일 경우:\n@f @g x\n\n\n여러 행일 경우:\n@f\n@g\nx\n\n\n\n여러 데코레이터가 단일 선언에 적용되는 경우는 수학의 합성 함수와 유사합니다.\n이 모델에서 함수 f와 g을 합성할 때 (f∘g)(x)의 합성 결과는 f(g(x))와 같습니다.\n따라서 TypeScript에서 단일 선언에서 여러 데코레이터를 사용할 때 다음 단계가 수행됩니다.\n\n각 데코레이터의 표현은 위에서 아래로 평가됩니다.\n그런 다음 결과는 아래에서 위로 함수로 호출됩니다.\n\n데코레이터 팩토리를 사용하는 경우 다음 예제를 통해 이 수행 순서를 관찰 할 수 있습니다.\nfunction f() {\n    console.log(\"f(): evaluated\");\n    return function (target, propertyKey: string, descriptor: PropertyDescriptor) {\n        console.log(\"f(): called\");\n    }\n}\n\nfunction g() {\n    console.log(\"g(): evaluated\");\n    return function (target, propertyKey: string, descriptor: PropertyDescriptor) {\n        console.log(\"g(): called\");\n    }\n}\n\nclass C {\n    @f()\n    @g()\n    method() {}\n}\n\n이는 결과를 콘솔에 출력합니다.\nf(): evaluated\ng(): evaluated\ng(): called\nf(): called\n\n데코레이터 평가 (Decorator Evaluation)\n클래스에서 다양한 선언에 데코레이터를 적용하는 방법은 다음과 같이 잘 정의되어 있습니다.\n\n메서드, 접근자 또는 프로퍼티 데코레이터가 다음에 오는 매개 변수 데코레이터는 각 인스턴스 멤버에 적용됩니다.\n메서드, 접근자 또는 프로퍼티 데코레이터가 다음에 오는 매개 변수 데코레이터는 각 정적 멤버에 적용됩니다.\n매개 변수 데코레이터는 생성자에 적용됩니다.\n클래스 데코레이터는 클래스에 적용됩니다.\n\n클래스 데코레이터 (Class Decorators)\n클래스 데코레이터는 클래스 선언 직전에 선언됩니다.\n클래스 데코레이터는 클래스 생성자에 적용되며 클래스 정의를 관찰, 수정 또는 교체하는 데 사용할 수 있습니다.\n클래스 데코레이터는 선언 파일이나 다른 주변 컨텍스트 (예: 선언 클래스)에서 사용할 수 없습니다.\n클래스 데코레이터의 표현식은 데코레이팅된 클래스의 생성자를 유일한 인수로 런타임에 함수로 호출됩니다.\n클래스 데코레이터가 값을 반환하면 클래스가 선언을 제공하는 생성자 함수로 바꿉니다.\n\n참고  새 생성자 함수를 반환하도록 선택한 경우 원래 프로토타입을 유지 관리해야 합니다.\n런타임에 데코레이터를 적용하는 로직은 이 기능을 대신해주지 않습니다.\n\n다음은Greeter 클래스에 적용된 클래스 데코레이터 (@sealed)의 예입니다.\n@sealed\nclass Greeter {\n    greeting: string;\n    constructor(message: string) {\n        this.greeting = message;\n    }\n    greet() {\n        return \"Hello, \" + this.greeting;\n    }\n}\n\n다음 함수 선언을 사용하여 @sealed 데코레이터를 정의할 수 있습니다.\nfunction sealed(constructor: Function) {\n    Object.seal(constructor);\n    Object.seal(constructor.prototype);\n}\n\n@sealed가 실행되면 생성자와 프로토 타입을 모두 감쌉니다.\n생성자를 재정의하는 방법에 대한 예제는 다음과 같습니다.\nfunction classDecorator(constructor:T) {\n    return class extends constructor {\n        newProperty = \"new property\";\n        hello = \"override\";\n    }\n}\n\n@classDecorator\nclass Greeter {\n    property = \"property\";\n    hello: string;\n    constructor(m: string) {\n        this.hello = m;\n    }\n}\n\nconsole.log(new Greeter(\"world\"));\n\n메서드 데코레이터 (Method Decorators)\n메서드 데코레이터는 메서드 선언 직전에 선언됩니다.\n데코레이터는 메서드의 프로퍼티 설명자(Property Descriptor) 에 적용되며 메서드 정의를 관찰, 수정 또는 대체하는 데 사용할 수 있습니다.\n메서드 데코레이터는 선언 파일, 오버로드 또는 기타 주변 컨텍스트(예: 선언 클래스)에서 사용할 수 없습니다.\n메서드 데코레이터의 표현식은 런타임에 다음 세 개의 인수와 함께 함수로 호출됩니다:\n\n정적 멤버에 대한 클래스의 생성자 함수 또는 인스턴스 멤버에 대한 클래스의 프로토타입입니다.\n멤버의 이름\n멤버의 프로퍼티 설명자\n\n\n참고  스크립트 대상이 'ES5'보다 낮은 경우 프로퍼티 설명자 는 'undefined'이 됩니다.\n\n메서드 데코레이터가 값을 반환하면, 메서드의 프로퍼티 설명자 로 사용됩니다.\n\n참고  스크립트 대상이 'ES5'보다 낮은 경우 반환 값은 무시됩니다.\n\n다음은 Greeter 클래스의 메서드에 적용된 메서드 데코레이터 (@ enumerable)의 예입니다:\nclass Greeter {\n    greeting: string;\n    constructor(message: string) {\n        this.greeting = message;\n    }\n\n    @enumerable(false)\n    greet() {\n        return \"Hello, \" + this.greeting;\n    }\n}\n\n다음 함수 선언을 사용하여 @enumerable 데코레이터를 정의할 수 있습니다.\nfunction enumerable(value: boolean) {\n    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {\n        descriptor.enumerable = value;\n    };\n}\n\n@enumerable(false)데코레이터는 데코레이터 팩토리입니다.\n@enumerable(false) 데코레이터가 호출되면 프로퍼티 설명자의 enumerable 프로퍼티를 수정합니다.\n접근자 데코레이터 (Accessor Decorators)\n접근자 데코레이터는 접근자 선언 바로 전에 선언됩니다.\n접근자 데코레이터는 접근자의 프로퍼티 설명자에 적용되며 접근자의 정의를 관찰, 수정 또는 교체하는 데 사용할 수 있습니다.\n접근자 데코레이터는 선언 파일이나 다른 주변 컨텍스트(예: 선언 클래스)에서 사용할 수 없습니다.\n\n참고  TypeScript는 단일 멤버에 대해 get 및 set 접근자를 데코레이팅 할 수 없습니다.\n대신 멤버의 모든 데코레이터를 문서 순서대로 지정된 첫 번째 접근자에 적용해야 합니다.\n왜냐하면, 데코레이터는 각각의 선언이 아닌 get과 set 접근자를 결합한 프로퍼티 설명자에 적용되기 때문입니다.\n\n접근자 데코레이터의 표현 식은 런타임에 다음 세 가지 인수와 함께 함수로 호출됩니다:\n\n정적 멤버에 대한 클래스의 생성자 함수 또는 인스턴스 멤버에 대한 클래스의 프로토타입\n멤버의 이름\n멤버의 프로퍼티 설명자\n\n\n참고  스크립트 대상이 'ES5'보다 낮은 경우 프로퍼티 설명자는 undefined가 됩니다.\n\n접근자 데코레이터가 값을 반환하면 멤버의 프로퍼티 설명자로 사용됩니다.\n\n참고  스크립트 대상이 'ES5'보다 낮은 경우 반환 값은 무시됩니다.\n\n다음은 Point 클래스의 멤버에 적용되는 접근자 데코레이터 (@configurable)의 예입니다:\nclass Point {\n    private _x: number;\n    private _y: number;\n    constructor(x: number, y: number) {\n        this._x = x;\n        this._y = y;\n    }\n\n    @configurable(false)\n    get x() { return this._x; }\n\n    @configurable(false)\n    get y() { return this._y; }\n}\n\n다음 함수 선언을 사용하여 @configurable 데코레이터를 정의할 수 있습니다:\nfunction configurable(value: boolean) {\n    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {\n        descriptor.configurable = value;\n    };\n}\n\n프로퍼티 데코레이터 (Property Decorators)\n프로퍼티 데코레이터는 프로퍼티 선언 바로 전에 선언됩니다.\n프로퍼티 데코레이터는 선언 파일이나 다른 주변 컨텍스트(예: 선언 클래스)에서 사용할 수 없습니다.\n프로퍼티 데코레이터의 표현 식은 런타임에 다음 두 개의 인수와 함께 함수로 호출됩니다:\n\n정적 멤버에 대한 클래스의 생성자 함수 또는 인스턴스 멤버에 대한 클래스의 프로토타입\n멤버의 이름\n\n\n참고  TypeScript에서 프로퍼티 데코레이터가 초기화되는 방식으로 인해 프로퍼티 설명자가 프로퍼티 데코레이터에 대한 인수로 제공되지 않습니다.\n현재 프로토타입의 멤버를 정의할 때 인스턴스 프로퍼티를 설명하는 메커니즘이 없고 프로퍼티의 이니셜라이저를 관찰하거나 수정할 수 있는 방법이 없기 때문입니다. 반환 값도 무시됩니다.\n따라서 프로퍼티 데코레이터는 특정 이름의 프로퍼티가 클래스에 선언되었음을 관찰하는 데만 사용할 수 있습니다.\n\n이 정보를 사용하여 다음 예와 같이 프로퍼티에 대한 메타데이터를 기록할 수 있습니다:\nclass Greeter {\n    @format(\"Hello, %s\")\n    greeting: string;\n\n    constructor(message: string) {\n        this.greeting = message;\n    }\n    greet() {\n        let formatString = getFormat(this, \"greeting\");\n        return formatString.replace(\"%s\", this.greeting);\n    }\n}\n\n다음 함수 선언을 사용하여 @format 데코레이터와 getFormat 함수를 정의 할 수 있습니다:\nimport \"reflect-metadata\";\n\nconst formatMetadataKey = Symbol(\"format\");\n\nfunction format(formatString: string) {\n    return Reflect.metadata(formatMetadataKey, formatString);\n}\n\nfunction getFormat(target: any, propertyKey: string) {\n    return Reflect.getMetadata(formatMetadataKey, target, propertyKey);\n}\n\n@format(\"Hello, %s\") 데코레이터는 데코레이터 팩토리입니다.\n@format(\"Hello, %s\")가 호출되면 reflect-metadata 라이브러리의 Reflect.metadata 함수를 사용하여 프로퍼티에 대한 메타데이터 항목을 추가합니다.\ngetFormat이 호출되면 형식의 메타데이터 값을 읽습니다.\n\n참고  이 예제에는 reflect-metadata 라이브러리가 필요합니다.\nreflect-metadata 라이브러리에 대한 자세한 내용은 메타데이터를 참조하십시오.\n\n매개변수 데코레이터 (Parameter Decorators)\n매개변수 데코레이터는 매개 변수 선언 직전에 선언됩니다.\n매개변수 데코레이터는 클래스 생성자 또는 메서드 선언의 함수에 적용됩니다.\n매개변수 데코레이터는 선언 파일, 오버로드 또는 다른 주변 컨텍스트(예: 선언 클래스)에서 사용할 수 없습니다.\n매개 변수 데코레이터의 표현식은 런타임시 다음 세 개의 인수와 함께 함수로 호출됩니다:\n\n정적 멤버에 대한 클래스의 생성자 함수 또는 인스턴스 멤버에 대한 클래스의 프로토타입\n멤버의 이름\n함수의 매개 변수 목록에 있는 매개 변수의 서수 색인(ordinal index)\n\n\n참고  매개변수 데코레이터는 매개변수가 메서드에서 선언되었을 때에만 관찰하는 데에 사용할 수 있습니다.\n\n메개변수 데코레이터의 반환 값은 무시됩니다.\n다음은 Greeter 클래스 멤버의 매개 변수에 적용되는 매개 변수 데코레이터 (@required)의 예입니다:\nclass Greeter {\n    greeting: string;\n\n    constructor(message: string) {\n        this.greeting = message;\n    }\n\n    @validate\n    greet(@required name: string) {\n        return \"Hello \" + name + \", \" + this.greeting;\n    }\n}\n\n다음 함수 선언을 사용하여 @required 및 @validate 데코레이터를 정의할 수 있습니다.\nimport \"reflect-metadata\";\n\nconst requiredMetadataKey = Symbol(\"required\");\n\nfunction required(target: Object, propertyKey: string | symbol, parameterIndex: number) {\n    let existingRequiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyKey) || [];\n    existingRequiredParameters.push(parameterIndex);\n    Reflect.defineMetadata(requiredMetadataKey, existingRequiredParameters, target, propertyKey);\n}\n\nfunction validate(target: any, propertyName: string, descriptor: TypedPropertyDescriptor) {\n    let method = descriptor.value;\n    descriptor.value = function () {\n        let requiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyName);\n        if (requiredParameters) {\n            for (let parameterIndex of requiredParameters) {\n                if (parameterIndex >= arguments.length || arguments[parameterIndex] === undefined) {\n                    throw new Error(\"Missing required argument.\");\n                }\n            }\n        }\n\n        return method.apply(this, arguments);\n    }\n}\n\n@required 데코레이터는 필요에 따라 매개변수를 표시하는 메타데이터 항목을 추가합니다.\n그런 다음 @validate 데코레이터는 원래 메서드를 호출하기 전에 인수 유효성 검증하는 함수로 기존의 greet 메서드를 감쌉니다.\n\n참고  이 예제에는 reflect-metadata 라이브러리가 필요합니다.\nreflect-metadata 라이브러리에 대한 자세한 내용은 [메타데이터] (#메타데이터-metadata)를 참조하십시오.\n\n메타데이터 (Metadata)\n일부 예제는 실험적 메타데이터 API에 대한 폴리필(polyfill)을 추가하는 reflect-metadata 라이브러리를 사용합니다.\n이 라이브러리는 아직 ECMAScript (JavaScript) 표준의 일부가 아닙니다.\n그러나 데코레이터가 공식적으로 ECMAScript 표준의 일부로 채택되면 이러한 확장을 채택하게 될 것입니다.\nnpm을 통해 설치할 수 있습니다.\nnpm i reflect-metadata --save\n\nTypeScript에는 데코레이터가 있는 선언에 대해 특정 타입의 메타 데이터를 내보내는 실험적인 지원을 포함합니다.\n이 실험적인 지원을 가능하게 하려면, 명령행 또는tsconfig.json에서 emitDecoratorMetadata 컴파일러 옵션을 설정해야 합니다.\n명령줄:\ntsc --target ES5 --experimentalDecorators --emitDecoratorMetadata\n\ntsconfig.json:\n{\n    \"compilerOptions\": {\n        \"target\": \"ES5\",\n        \"experimentalDecorators\": true,\n        \"emitDecoratorMetadata\": true\n    }\n}\n\n활성화되면 reflect-metadata라이브러리를 가져오기만 하면 추가 디자인-타임 타입 정보가 런타임에 사용 가능합니다.\n다음 예제에서 이를 확인할 수 있습니다.\nimport \"reflect-metadata\";\n\nclass Point {\n    x: number;\n    y: number;\n}\n\nclass Line {\n    private _p0: Point;\n    private _p1: Point;\n\n    @validate\n    set p0(value: Point) { this._p0 = value; }\n    get p0() { return this._p0; }\n\n    @validate\n    set p1(value: Point) { this._p1 = value; }\n    get p1() { return this._p1; }\n}\n\nfunction validate(target: any, propertyKey: string, descriptor: TypedPropertyDescriptor) {\n    let set = descriptor.set;\n    descriptor.set = function (value: T) {\n        let type = Reflect.getMetadata(\"design:type\", target, propertyKey);\n        if (!(value instanceof type)) {\n            throw new TypeError(\"Invalid type.\");\n        }\n        set.call(target, value);\n    }\n}\n\nTypeScript 컴파일러는 @Reflect.metadata 데코레이터를 사용하여 디자인-타임 타입 정보를 주입합니다.\n다음 TypeScript와 동일하다고 생각할 수 있습니다.\nclass Line {\n    private _p0: Point;\n    private _p1: Point;\n\n    @validate\n    @Reflect.metadata(\"design:type\", Point)\n    set p0(value: Point) { this._p0 = value; }\n    get p0() { return this._p0; }\n\n    @validate\n    @Reflect.metadata(\"design:type\", Point)\n    set p1(value: Point) { this._p1 = value; }\n    get p1() { return this._p1; }\n}\n\n\n참고  데코레이터 메타 데이터는 실험적인 기능으로 향후 릴리스에서 주요 변경 사항이 있을 수 있습니다.\n\n"},"pages/Mixins.html":{"url":"pages/Mixins.html","title":"믹스인","keywords":"","body":"Mixin\n소개(Introduction)\n전통적인 객쳬지향 계층과 함께, 재사용 가능한 컴포넌트로 부터 클래스를 빌드하는 또 다른 일반적인 방법으로, 간단한 부분클래스를 결합하여 빌드하는 것입니다. 스칼라 등의 언어를 통해서, 믹스인에 대한 개념과 특성은 익숙할 수 있을 것이며, 패턴은 JavaScript 커뮤니티에서도 어느 정도의 인기를 얻었습니다.\n예시 코드(Code Sample)\n아래 코드에서는 TypeScript에서 mixin의 모델링 방식을 보여줍니다. 코드를 본 후, 작동 방식을 살펴보도록 하겠습니다.\n// Disposable Mixin\nclass Disposable {\n    isDisposed: boolean;\n    dispose() {\n        this.isDisposed = true;\n    }\n\n}\n\n// Activatable Mixin\nclass Actiavatable {\n    isActive: boolean;\n    activate() {\n        this.isActive = true;\n    }\n    deactivate() {\n        this.isActive = false;\n    }\n}\n\nclass SmartObject {\n    constructor() {\n        setInterval(() => console.log(this.isActive + \" : \" + this.isDisposed), 500);\n    }\n\n    interact() {\n        this.activate();\n    }\n}\n\ninterface SmartObject extends Disposable, Activatable {}\napplyMixins(SmartObject, [Disposable, Activatable]);\n\nlet smartObj = new SmartObject();\nsetTimeout(() => smartObj.interact(), 1000);\n\n////////////////////////////////////////\n// In your runtime library somewhere\n////////////////////////////////////////\n\nfunction applyMixins(derivedCtor: any, baseCtors: any[]) {\n    baseCtors.forEach(baseCtor => {\n        Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {\n            Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name));\n        });\n    });\n}\n\n예시 알아보기(Understanding the sample)\n예시 코드는 mixin을 수행하는 두 클래스로 시작합니다. 두 클래스는 각각 부분적인 기능에 집중되어 있음을 알 수 있습니다. 이후에는 두 기능을 모두 사용하여 새로운 클래스를 만들기 위해 이들을 혼합(mix)할 것입니다.\n// Disposable Mixin\nclass Disposable {\n    isDisposed: boolean;\n    dispose() {\n        this.isDisposed = true;\n    }\n\n}\n\n// Activatable Mixin\nclass Activatable {\n    isActive: boolean;\n    activate() {\n        this.isActive = true;\n    }\n    deactivate() {\n        this.isActive = false;\n    }\n}\n\n다음으로, 두 mixin의 결합을 처리 할 클래스를 만듭니다. 이것이 어떻게 작동하는지 더 자세히 살펴 보겠습니다.\nclass SmartObject {\n    ...\n}\n\ninterface SmartObject extends Disposable, Activatable {}\n\n첫 번째 사항은 SmartObject 클래스에서 Disposable과 Activatable을 확장하는 대신 SmartObject 인터페이스에서 확장한다는 것입니다. Declaration merging으로 인해 SmartObject 인터페이스가 SmartObject 클래스에 혼합됩니다.\n클래스를 인터페이스로 취급하고 Disposable 및 Activatable 뒤에있는 유형 만 구현이 아닌 SmartObject 유형으로 혼합합니다. 이것은 우리가 클래스에서 구현에서 mixin을 제공해야 한다는 것을 의미합니다. 그 외에는 mixin의 사용을 피할 수 있습니다.\n마지막으로 클래스에 구현에서, mixin을 혼합(mix)합니다.\napplyMixins(SmartObject, [Disposable, Activatable]);\n\n마지막으로, 우리를 위해 mixin을 수행 할 도우미 함수를 만듭니다. 그러면 각 mixin의 속성이 실행되고 mixin의 대상으로 복사되어 독립형 속성을 구현합니다.\nfunction applyMixins(derivedCtor: any, baseCtors: any[]) {\n    baseCtors.forEach(baseCtor => {\n        Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {\n            Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name));\n        });\n    });\n}\n\n"},"pages/Triple-Slash Directives.html":{"url":"pages/Triple-Slash Directives.html","title":"트리플-슬래시 지시자","keywords":"","body":"트리플-슬래시(Triple-slash) 지시어는 단일 XML 태그를 포함하는 한 줄 주석입니다.\n주석의 내용은 컴파일러 지시어로 사용됩니다.\n트리플-슬래시 지시어는 오직 포함된 파일의 상단에서만 유효합니다.\n트리플-슬래시 지시어는 다른 트리플-슬래시 지시어를 포함한 한 줄 혹은 여러 줄의 주석 앞에만 위치할 수 있습니다.\n만약 문 혹은 선언 뒤에 나오는 경우, 보통의 한 줄 주석으로 여겨지며 어떤 특별한 의미도 갖지 않습니다.\n/// \n///  지시어는 가장 일반적인 지시어입니다.\n파일 간 의존성 선언으로 사용됩니다.\n트리플-슬래시 참조는 컴파일 프로세스에 추가적인 파일을 포함하도록 컴파일러에게 지시합니다.\n또한 --out 또는 --outFile을 사용할 때 출력물을 정렬하기 위한 방법으로도 사용됩니다.\n파일은 전처리 통과 후 입력과 동일한 순서로 출력 파일 위치에 생성됩니다.\n입력 파일 전처리 (Preprocessing input files)\n컴파일러는 모든 트리플-슬래시 참조 지시어를 분석하기 위해 입력 파일에 대한 전처리를 수행합니다.\n이 과정에서, 추가 파일이 컴파일에 추가됩니다.\n이 과정은 root files 집합에서 시작합니다;\n이것들은 커맨드-라인이나 tsconfig.json 파일의 \"files\"목록에 지정된 파일 이름입니다.\n이 루트 파일들은 지정된 순서대로 전처리 됩니다.\n파일이 목록에 추가되기 전, 파일에 있는 모든 트리플-슬래시 참조가 처리되고 그 대상들이 포함됩니다.\n트리플-슬래시 참조는 파일에서 보이는 순서대로 깊이 우선으로 처리됩니다.\n루트가 없는 경우 트리플-슬래시 참조 경로는 이를 포함하고 있는 파일을 기준으로 처리됩니다.\n오류 (Errors)\n존재하지 않는 파일을 참조하는 것은 오류입니다.\n파일이 자기 자신에 대한 트리플-슬래시 참조를 갖는 것은 오류입니다.\n--noResolve 사용하기 (Using --noResolve)\n컴파일러 플래그 --noResolve가 지정되면 트리플-슬래시 참조는 무시됩니다; 새 파일을 추가하거나 제공된 파일의 순서를 변경하지 않습니다.\n/// \n의존성을 선언 역할을 하는 ///  지시어와 유사하게, ///  지시어는 패키지의 의존성을 선언합니다.\n패키지 이름을 처리하는 과정은 import 문에서 모듈 이름을 처리하는 과정과 유사합니다.\n트리플-슬래시-참조-타입 지시어를 선언 패키지의 import로 생각하면 이해하기 쉽습니다.\n예를 들어, 선언 파일에 /// 를 포함하는 것은 이 파일이 @types/node/index.d.ts에 선언된 이름을 사용한다고 선언하며;\n따라서 이 패키지는 선언 파일과 함께 컴파일에 포함되어야 합니다.\n이 지시어는 d.ts 파일을 직접 작성할 때만 사용하세요.\n컴파일 중 생성된 선언 파일의 경우, 컴파일러는 자동으로 /// 를 추가합니다;\n오직 결과 파일이 참조된 패키지의 선언문을 사용하는 경우에만 생성된 선언 파일 안에 ///  가 추가됩니다.\n.ts 파일에서 @type의 패키지의 의존성을 선언하려면, 커맨드 라인에 --types 을 사용하거나  tsconfig.json을 사용하세요.\ntsconfig.json에서 @types, typeRoots 과 types 사용하기에서 세부 사항을 확인하세요.\n/// \n이 지시어는 파일이 명시적으로 기존 내장 lib 파일을 포함하도록 합니다.\n내장 lib 파일은 tsconfig.json의\"lib\"컴파일러 옵션과 같은 방식으로 참조됩니다 (예 :lib = \"es2015.d\"ts가 아닌 lib = \"es2015\"사용 등).\nDOM API 또는Symbol 또는 Iterable과 같은 내장 JS 런타임 생성자와 같은 내장 타입에 의존하는 선언 파일 작성자에게는 트리플 슬래시 참조 lib 지시어를 사용하는 것이 권장됩니다. 이전에는 이런 .d.ts 파일은 그런 타입의 전달/중복 선언을 추가했어야 했습니다.\n예를 들어 컴파일에서 파일 중 하나에 /// 를 추가한 것 것은 --lib es2017.string으로 컴파일 하는 것과 같습니다.\n/// \n\n\"foo\".padStart(4);\n\n/// \n이 지시어는 파일을 기본 라이브러리라고 표시합니다.\n이 주석은 lib.d.ts와 이를 변형한 것들의 맨 상단에서 볼 수 있습니다.\n이 지시어는 컴파일러에게 기본 라이브러리(예.lib.d.ts)를 컴파일에 포함시키지 않도록 지시합니다.\n이는 커맨드 라인에 --nolib을 넘겨주는 것과 비슷한 영향을 줍니다.\n또한 --skipDefaultLibCheck를 넘겨주면, 컴파일러가 ///  을 갖는 파일만 검사하지 않는다는 것을 유의하세요.\n/// \n기본적으로 AMD 모듈은 익명으로 생성됩니다.\n이는 모듈로 만들어 내는 과정에 번들러(예. r.js)와 같은 다른 툴을 사용할 경우 문제를 발생시킬 수 있습니다.\namd-module 지시어는 컴파일러에게 선택적으로 모듈의 이름을 넘길 수 있도록 해줍니다:\namdModule.ts\n///\nexport class C {\n}\n\n이는 AMD define 호출의 일부로 NamedModule 이름을 모듈에 할당하는 결과를 낳을 것입니다:\namdModule.js\ndefine(\"NamedModule\", [\"require\", \"exports\"], function (require, exports) {\n    var C = (function () {\n        function C() {\n        }\n        return C;\n    })();\n    exports.C = C;\n});\n\n/// \n\nNote: 이 지시어는 deprecated 되었습니다. 대신 import \"moduleName\"; 문을 사용하세요.\n\n/// 는 컴파일러에게 TS-가 아닌 모듈의 의존성이 결과 모듈의 require 호출에 추가되어야 한다고 알립니다.\namd-dependeny 지시어는 선택적으로 name 프로퍼티를 갖습니다; 이로 인해 amd-dependency에 선택적으로 이름을 전달할 수 있습니다:\n/// \ndeclare var moduleA:MyType\nmoduleA.callStuff()\n\n생성된 JS 코드:\ndefine([\"require\", \"exports\", \"legacy/moduleA\"], function (require, exports, moduleA) {\n    moduleA.callStuff()\n});\n\n"},"pages/Type Checking JavaScript Files.html":{"url":"pages/Type Checking JavaScript Files.html","title":"JavaScript 파일 타입 검사","keywords":"","body":"TypeScript 2.3 이상의 버전에서는 --checkJs를 사용해 .js 파일에서 타입 검사 및 오류 보고를 지원합니다.\n// @ts-nocheck 주석을 달아 일부 파일에서 타입 검사를 건너뛸 수 있으며; 반대로 // @ts-check 주석을 달아 --checkJs를 사용하지 않고 일부 .js 파일에 대해서만 타입 검사를 하도록 선택할 수 있습니다.\n또한 특정 부분의 앞 줄에 // @ts-ignore를 달아 에러를 무시할 수도 있습니다.\ntsconfig.json이 있는 경우, JavaScript 검사는 noImplicitAny, strictNullChecks 등의 엄격한 플래그를 우선시한다는 점을 알아두세요.\n하지만, JavaScript 검사의 상대적인 느슨함 덕분에 엄격한 플래그와 결합하여 사용하는 것은 놀라운 결과를 보여줄 것입니다.\n.ts 파일과 .js 파일은 타입을 검사하는 방법에 몇 가지 주목할만한 차이점이 있습니다:\n타입 정보로 사용되는 JSDoc 타입 (JSDoc types are used for type information)\n.js 파일에서는, 흔히 .ts 파일처럼 타입을 추론해볼 수 있습니다.\n타입을 추론할 수 없는 경우, .ts의 타입 표시와 같은 방법으로 JSDoc을 사용해 이를 지정할 수 있습니다.\nTypeScript와 마찬가지로, --noImplicitAny는 컴파일러가 타입을 유추할 수 없는 부분에서 오류를 보고할 것입니다.\n(확장 가능한 객체 리터럴을 제외하고; 자세한 내용은 아래를 참고하세요.)\n선언에 JSDoc 표시를 사용하면 해당 선언의 타입을 설정할 수 있습니다. 예를 들면:\n/** @type {number} */\nvar x;\n\nx = 0;      // 성공\nx = false;  // 오류: 불리언(boolean)에는 숫자를 할당할 수 없음\n\n사용 가능한 JSDoc 패턴 목록은 이곳에서 확인할 수 있습니다.\n클래스 본문의 할당에서 추론된 프로퍼티 (Properties are inferred from assignments in class bodies)\nES2015에는 클래스에 프로퍼티를 선언할 수 있는 수단이 없습니다. 프로퍼티는 객체 리터럴과 같이 동적으로 할당됩니다.\n.js 파일에서, 컴파일러는 클래스 본문 내부에서 할당된 프로퍼티로부터 프로퍼티들을 추론합니다.\n생성자가 정의되어 있지 않거나, 생성자에서 정의된 타입이 undefined나 null이 아닐 경우, 프로퍼티의 타입은 생성자에서 주어진 타입과 동일합니다.\n전자에 해당 프로퍼티의 경우, 할당되었던 모든 값들의 타입을 가진 유니언 타입이 됩니다.\n생성자에 정의된 프로퍼티는 항상 존재하는 것으로 가정하는 반면, 메서드, getter, setter에서만 정의된 프로퍼티는 선택적인 것으로 간주합니다.\nclass C {\n    constructor() {\n        this.constructorOnly = 0\n        this.constructorUnknown = undefined\n    }\n    method() {\n        this.constructorOnly = false // 오류, constructorOnly는 Number 타입임\n        this.constructorUnknown = \"plunkbat\" // 성공, constructorUnknown의 타입은 string | undefined\n        this.methodOnly = 'ok'  // 성공, 그러나 methodOnly는 undefined 타입 또한 허용됨\n    }\n    method2() {\n        this.methodOnly = true  // 이 또한 성공, methodOnly의 타입은 string | boolean | undefined\n    }\n}\n\n프로퍼티가 클래스 본문에서 설정되지 않았다면, 알 수 없는 것으로 간주합니다.\n클래스에 읽기 전용 프로퍼티가 있는 경우, 생성자에서 선언에 JSDoc을 사용하여 타입을 추가하여 표시합니다.\n이후엔 초기화하더라도 값을 지정할 필요가 없습니다.\nclass C {\n    constructor() {\n        /** @type {number | undefined} */\n        this.prop = undefined;\n        /** @type {number | undefined} */\n        this.count;\n    }\n}\n\nlet c = new C();\nc.prop = 0;          // 성공\nc.count = \"string\";  // 오류: string 은 number|undefined에 할당할 수 없음\n\n생성자 함수와 클래스는 동일 (Constructor functions are equivalent to classes)\nES2015 이전에는, JavaScript는 클래스 대신 생성자 함수를 사용했습니다.\n컴파일러는 이러한 패턴을 지원하며 생성자 함수를 ES2015 클래스와 동일한 것으로 이해합니다.\n앞서 설명한 프로퍼티 추론 규칙 또한 정확히 같은 방식으로 작용합니다.\nfunction C() {\n    this.constructorOnly = 0\n    this.constructorUnknown = undefined\n}\nC.prototype.method = function() {\n    this.constructorOnly = false // 오류\n    this.constructorUnknown = \"plunkbat\" // 성공, 타입은 string | undefined가 됨\n}\n\nCommonJS 모듈 지원 (CommonJS modules are supported)\n.js 파일에서, TypeScript는 CommonJS 모듈 포맷을 이해합니다.\nexports와 module.exports 할당은 export 선언으로 인식됩니다.\n마찬가지로, require 함수 호출은 모듈 import로 인식됩니다. 예를 들어:\n// `import module \"fs\"`와 같음\nconst fs = require(\"fs\");\n\n// `export function readFile`과 같음\nmodule.exports.readFile = function(f) {\n    return fs.readFileSync(f);\n}\n\nJavaScript의 모듈 지원은 TypeScript의 모듈 지원보다 구문적으로 훨씬 관용적입니다.\n따라서 대부분의 할당과 선언의 조합이 지원됩니다.\n클래스, 함수, 객체 리터럴은 네임스페이스 (Classes, functions, and object literals are namespaces)\n.js 파일에 있는 클래스는 네임스페이스입니다.\n예를 들어, 다음과 같이 클래스를 중첩하는 데에 사용할 수 있습니다:\nclass C {\n}\nC.D = class {\n}\n\n그리고 ES2015 이전 코드의 경우, 정적 메서드를 나타내는 데에 사용할 수도 있습니다:\nfunction Outer() {\n  this.y = 2\n}\nOuter.Inner = function() {\n  this.yy = 2\n}\n\n또한 간단한 네임스페이스를 생성하는 데에 사용할 수도 있습니다:\nvar ns = {}\nns.C = class {\n}\nns.func = function() {\n}\n\n다른 번형도 허용됩니다:\n// 즉시 호출 함수(IIFE)\nvar ns = (function (n) {\n  return n || {};\n})();\nns.CONST = 1\n\n// 전역으로 기본 설정\nvar assign = assign || function() {\n  // 여기엔 코드를\n}\nassign.extra = 1\n\n객체 리터럴은 확장 가능 (Object literals are open-ended)\n.ts 파일에서, 변수 선언을 초기화하는 객체 리터럴은 선언에 해당 타입을 부여합니다.\n원본 리터럴에 명시되어 있지 않은 새 멤버는 추가될 수 없습니다.\n이 규칙은 .js 파일에선 완화됩니다; 객체 리터럴은 원본에 정의되지 않은 새로운 프로퍼티를 조회하고 추가하는 것이 허용되는 확장 가능한 타입(인덱스 시그니처)을 갖습니다.\n예를 들어:\nvar obj = { a: 1 };\nobj.b = 2;  // 허용됨\n\n객체 리터럴은 마치 닫힌 객체가 아니라 열린 맵(maps)으로 다뤄지도록 [x:string]: any와 같은 인덱스 시그니처를 가진 것처럼 동작합니다.\n다른 특정 JavaScript 검사 동작과 마찬가지로, 해당 동작은 변수에 JSDoc 타입을 지정하여 변경할 수 있습니다. 예를 들어:\n/** @type {{a: number}} */\nvar obj = { a: 1 };\nobj.b = 2;  // 오류, {a: number}타입엔 b 프로퍼티가 없음\n\nnull, undefined 및 빈 배열 이니셜라이저는 any 혹은 any[] 타입 (null, undefined, and empty array initializers are of type any or any[])\nnull 또는 undefined로 초기화된 변수나 매개변수 또는 프로퍼티는, 엄격한 null 검사가 있더라도 any 타입을 갖게 될 것입니다.\n[]로 초기화된 변수나 매개변수 또는 프로퍼티는, 엄격한 null 검사가 있더라도 any[] 타입을 갖게 될 것입니다.\n위에서 설명한 여러 이니셜라이저(initializer)를 갖는 프로퍼티만이 유일한 예외입니다.\nfunction Foo(i = null) {\n    if (!i) i = 1;\n    var j = undefined;\n    j = 2;\n    this.l = [];\n}\nvar foo = new Foo();\nfoo.l.push(foo.i);\nfoo.l.push(\"end\");\n\n함수 매개변수는 기본적으로 선택 사항 (Function parameters are optional by default)\nES2015 이전의 JavaScript는 선택적인 매개변수를 지정할 방법이 없었기 때문에, .js 파일에선 모든 함수의 매개변수는 선택적인 것으로 간주됩니다.\n선언된 매개변수보다 적은 인수로 호출하는 것이 허용됩니다.\n그러나 너무 많은 인수를 넣어 호출하면 오류를 일으킨다는 것에 유의하세요.\n예를 들어:\nfunction bar(a, b) {\n    console.log(a + \" \" + b);\n}\n\nbar(1);       // 성공, 두 번째 인수는 선택 사항임\nbar(1, 2);\nbar(1, 2, 3); // 오류, 인수의 갯수가 너무 많음\n\nJSDoc 표시가 된 함수는 이 규칙에서 예외입니다.\nJSDoc의 선택적 매개변수 구문을 사용하여 선택 사항을 표시할 수 있습니다. 예시:\n/**\n * @param {string} [somebody] - 누군가의 이름\n */\nfunction sayHello(somebody) {\n    if (!somebody) {\n        somebody = 'John Doe';\n    }\n    console.log('Hello ' + somebody);\n}\n\nsayHello();\n\narguments 사용으로부터 추론된 var-args 매개변수 선언 (Var-args parameter declaration inferred from use of arguments)\narguments 참조를 참조하는 본문을 가진 함수는, 암묵적으로 var-args 매개변수(예: (...arg: any[]) => any)를 갖는 것으로 간주합니다. JSDoc의 var-args 구문을 사용하여 인수의 타입을 지정할 수 있습니다.\n/** @param {...number} args */\nfunction sum(/* numbers */) {\n    var total = 0\n    for (var i = 0; i \n타입이 지정되지 않은 매개변수는 기본적으로 any임 (Unspecified type parameters default to any)\nJavaScript에는 제네릭 타입의 매개변수를 지정하는 구문이 없으므로, 타입이 지정되지 않은 매개변수는 기본적으로 any 타입입니다.\n확장 절에서 (In extends clause)\n예를 들어, React.Component는 Props와 State라는 두 타입의 매개변수를 갖도록 정의되어 있습니다.\n.js 파일에는 이러한 것들을 확장 절에 지정할 수 있는 정당한 방법이 없습니다. 기본적으로 해당 타입 인수는 any가 될 것입니다:\nimport { Component } from \"react\";\n\nclass MyComponent extends Component {\n    render() {\n        this.props.b; // this.props의 타입이 any이므로 허용됨\n    }\n}\n\n타입을 명시적으로 지정하려면 JSDoc의 @augments를 사용하세요. 예를 들어:\nimport { Component } from \"react\";\n\n/**\n * @augments {Component}\n */\nclass MyComponent extends Component {\n    render() {\n        this.props.b; // 오류: b 는 {a:number}에 속하지 않음\n    }\n}\n\nJSDoc 참조에서 (In JSDoc references)\nJSDoc의 지정되지 않은 타입 인수는 기본적으로 any입니다:\n/** @type{Array} */\nvar x = [];\n\nx.push(1);        // 성공\nx.push(\"string\"); // 성공, x는 Array 타입임\n\n/** @type{Array.} */\nvar y = [];\n\ny.push(1);        // 성공\ny.push(\"string\"); // 오류, string을 number 타입에 할당할 수 없음\n\n함수 호출에서 (In function calls)\n제네릭 함수의 호출은 인수를 사용해 타입 매개변수를 추론합니다. 때때로 이 과정은 추론 소스가 부족하여 어떠한 타입도 추론하지 못하는 경우가 있습니다; 이러한 경우, 매개변수 타입은 기본적으로 any입니다. 예를 들어:\nvar p = new Promise((resolve, reject) => { reject() });\n\np; // Promise;\n\n지원되는 JSDoc (Supported JSDoc)\n아래의 구성은 JavaScript 파일에서 JSDoc 주석을 사용하여 타입 정보를 제공할 때 지원되는 목록입니다.\n아래에 명시되지 않은 태그(@async 등)는 아직 지원되지 않는다는 점에 유의하세요.\n\n@type\n@param (또는 @arg 또는 @argument)\n@returns (또는 @return)\n@typedef\n@callback\n@template\n@class (또는 @constructor)\n@this\n@extends (또는 @augments)\n@enum\n\n대부분의 태그의 의미는 usejsdoc.org에서 설명하는 태그의 의미와 같습니다.\n아래의 코드는 차이점을 설명하고 각 태그의 사용 예시를 설명합니다.\n@type\n\"@type\" 태그를 사용하고 타입 이름을 참조(원래 TypeScript의 선언에 정의된 것 또는 JSDoc의 \"@typedef\" 태그 중 하나)할 수 있습니다.\n모든 TypeScript의 타입, 대부분의 JSDoc 타입 중 어떤 것이든 사용할 수 있습니다.\n/**\n * @type {string}\n */\nvar s;\n\n/** @type {Window} */\nvar win;\n\n/** @type {PromiseLike} */\nvar promisedString;\n\n// HTML 요소를 DOM 프로퍼티로 지정할 수 있음\n/** @type {HTMLElement} */\nvar myElement = document.querySelector(selector);\nelement.dataset.myData = '';\n\n@type은 유니언 타입으로 지정할 수 있습니다; 예를 들어, 문자열과 불리언 중 어떤 것이든 될 수 있습니다.\n/**\n * @type {(string | boolean)}\n */\nvar sb;\n\n유니언 타입에는 괄호가 선택 사항이라는 점에 유의하세요.\n/**\n * @type {string | boolean}\n */\nvar sb;\n\n다양한 구문을 사용하여 배열 타입을 지정할 수도 있습니다:\n/** @type {number[]} */\nvar ns;\n/** @type {Array.} */\nvar nds;\n/** @type {Array} */\nvar nas;\n\n또한 객체 리터럴 타입을 지정할 수도 있습니다.\n예를 들어, 프로퍼티 'a' (string) 와 'b' (number)를 갖는 오브젝트라면 다음과 같은 구문을 사용할 수 있습니다.\n/** @type {{ a: string, b: number }} */\nvar var9;\n\n표준 JSDoc 구문 또는 TypeScript 구문을 통해 문자열 혹은 숫자 인덱스 시그니처를 사용하여 유사-맵 혹은 유사-배열 오브젝트를 지정할 수도 있습니다.\n/**\n * 임의의 `string` 프로퍼티를 `number`에 매핑하는 유사-맵 객체.\n *\n * @type {Object.}\n */\nvar stringToNumber;\n\n/** @type {Object.} */\nvar arrayLike;\n\n앞의 두 타입은 TypeScript의 { [x: string]: number } 그리고 { [x: number]: any }와 동일합니다. 컴파일러는 두 구문을 모두 이해할 것입니다.\n함수 타입은 TypeScript 또는 클로저 구문을 사용하여 지정할 수 있습니다:\n/** @type {function(string, boolean): number} Closure 구문 */\nvar sbn;\n/** @type {(s: string, b: boolean) => number} TypeScript 구문 */\nvar sbn2;\n\n혹은 단순히 지정되지 않은 Function 타입을 사용할 수도 있습니다:\n/** @type {Function} */\nvar fn7;\n/** @type {function} */\nvar fn6;\n\nClosure의 다른 타입 또한 동작합니다:\n/**\n * @type {*} - 어떠한 타입이든 될 수 있음\n */\nvar star;\n/**\n * @type {?} - 식별되지 않은 타입 ('any'와 같음)\n */\nvar question;\n\n캐스트 (Casts)\nTypeScript는 클로저의 캐스트(cast) 구문을 차용합니다.\n이는 괄호화된 표현식 앞에 @type 태그를 사용하여 다른 타입으로의 캐스트를 가능케 합니다.\n/**\n * @type {number | string}\n */\nvar numberOrString = Math.random() \n타입 import (Import types)\n타입 import를 사용하여 다른 파일의 선언을 가져올 수도 있습니다.\n이 구문은 TypeScript에 특화된 것이며 JSDoc 표준과는 조금 다릅니다:\n/**\n * @param p { import(\"./a\").Pet }\n */\nfunction walk(p) {\n    console.log(`Walking ${p.name}...`);\n}\n\n타입 import는 타입 별칭 선언에서도 쓰일 수 있습니다:\n/**\n * @typedef { import(\"./a\").Pet } Pet\n */\n\n/**\n * @type {Pet}\n */\nvar myPet;\nmyPet.name;\n\n타입을 모르거나 입력하기 귀찮은 큰 타입이 있을 경우, 타입 import를 사용하여 모듈에서 값의 타입을 가져올 수 있습니다:\n/**\n * @type {typeof import(\"./a\").x }\n */\nvar x = require(\"./a\").x;\n\n@param and @returns\n@param은 @type과 같은 종류의 구문을 사용하지만, 매개변수의 이름이 추가됩니다.\n매개변수는 이름을 대괄호로 둘러싸서 선택적으로 선언할 수 있습니다:\n// 매개변수는 다양한 형태의 구문으로 선언될 수 있음\n/**\n * @param {string}  p1 - 문자열 매개변수.\n * @param {string=} p2 - 선택적 문자열 매개변수 (클로저 구문)\n * @param {string} [p3] - 또다른 선택적 매개변수 (JSDoc 구문).\n * @param {string} [p4=\"test\"] - 기본값을 가진 선택적 매개변수\n * @return {string} 결과\n */\nfunction stringsStringStrings(p1, p2, p3, p4){\n  // TODO\n}\n\n마찬가지로, 함수의 반환 타입으로는:\n/**\n * @return {PromiseLike}\n */\nfunction ps(){}\n\n/**\n * @returns {{ a: string, b: number }} - '@returns'과 '@return' 모두 사용 가능\n */\nfunction ab(){}\n\n@typedef, @callback, and @param\n@typedef를 사용해 복잡한 타입을 정의할 수 있습니다.\n@param과 비슷한 구문으로 동작합니다.\n/**\n * @typedef {Object} SpecialType - 'SpecialType'이라는 새 타입을 생성\n * @property {string} prop1 - SpecialType의 문자열 프로퍼티\n * @property {number} prop2 - SpecialType의 숫자 프로퍼티\n * @property {number=} prop3 - SpecialType의 선택적 숫자 프로퍼티\n * @prop {number} [prop4] - SpecialType의 선택적 숫자 프로퍼티\n * @prop {number} [prop5=42] - SpecialType의 기본값을 가진 선택적 숫자 프로퍼티\n */\n/** @type {SpecialType} */\nvar specialTypeObject;\n\n첫 번째 줄에 object나 Object를 사용할 수 있습니다.\n/**\n * @typedef {object} SpecialType1 - 'SpecialType1'이라는 새 타입 생성\n * @property {string} prop1 - SpecialType1의 문자열 프로퍼티\n * @property {number} prop2 - SpecialType1의 숫자 프로퍼티\n * @property {number=} prop3 - SpecialType1의 선택적 숫자 프로퍼티\n */\n/** @type {SpecialType1} */\nvar specialTypeObject1;\n\n@param은 일회성인 타입 지정에 대한 비슷한 구문을 허용합니다.\n중첩된 프로퍼티 이름 앞엔 매개변수 이름을 붙여야 함을 유의하세요:\n/**\n * @param {Object} options - 해당 형태는 위의 SpecialType과 동일\n * @param {string} options.prop1\n * @param {number} options.prop2\n * @param {number=} options.prop3\n * @param {number} [options.prop4]\n * @param {number} [options.prop5=42]\n */\nfunction special(options) {\n  return (options.prop4 || 1001) + options.prop5;\n}\n\n@callback은 @typedef와 비슷합니다만, 객체 타입 대신 함수의 타입을 지정합니다:\n/**\n * @callback Predicate\n * @param {string} data\n * @param {number} [index]\n * @returns {boolean}\n */\n/** @type {Predicate} */\nconst ok = s => !(s.length % 2);\n\n물론, 이러한 유형 중 어떤 것이라도 단일 라인의 @typedef TypeScript 구문을 사용해 선언될 수 있습니다:\n/** @typedef {{ prop1: string, prop2: string, prop3?: number }} SpecialType */\n/** @typedef {(data: string, index?: number) => boolean} Predicate */\n\n@template\n@template 태그로 제네릭 타입을 선언할 수 있습니다:\n/**\n * @template T\n * @param {T} x - 리턴 타입까지 사용되는 제네릭 매개변수\n * @return {T}\n */\nfunction id(x){ return x }\n\n콤마 또는 여러 태그를 사용하여 여러 매개변수 타입을 선언할 수 있습니다:\n/**\n * @template T,U,V\n * @template W,X\n */\n\n타입 매개변수 이름 앞에 타입 제약 조건을 지정할 수도 있습니다.\n목록의 첫 번째 매개변수의 타입만 제한됩니다:\n/**\n * @template {string} K - K는 문자열 혹은 문자열 리터럴이어야만 함\n * @template {{ serious(): string }} Seriousalizable - serious 메서드를 가져야만 함\n * @param {K} key\n * @param {Seriousalizable} object\n */\nfunction seriousalize(key, object) {\n  // ????\n}\n\n@constructor\n컴파일러는 this-프로퍼티 할당을 기반으로 생성자 함수를 추론합니다만, @constructor 태그를 추가하여 보다 엄격한 검사와 더 나은 제안이 되도록 만들 수 있습니다.\n/**\n * @constructor\n * @param {number} data\n */\nfunction C(data) {\n  this.size = 0;\n  this.initialize(data); // 이니셜라이저에 문자열이 들어갈 경우, 오류 발생 가능\n}\n/**\n * @param {string} s\n */\nC.prototype.initialize = function (s) {\n  this.size = s.length\n}\n\nvar c = new C(0);\nvar result = C(1); // C는 새 인스턴스로만 호출해야 함\n\n@constructor를 사용하면, this는 C의 생성자 함수 내부에서 검사되므로, initailize 메서드에 대하여 알 수 있을 것이며 숫자를 넘길 경우 오류가 발생할 것입니다. 또한 C를 생성하지 않고 호출할 경우 오류를 일으킬 것입니다.\n불행하게도, 이는 호출 가능한 생성자 함수는 @constructor를 사용할 수 없다는 것을 의미합니다.\n@this\n컴파일러는 대게 작업할 컨텍스트가 있을 때 this의 타입을 알아낼 수 있습니다. 그렇지 않은 경우, @this를 사용해 this의 타입을 명시할 수 있습니다:\n/**\n * @this {HTMLElement}\n * @param {*} e\n */\nfunction callbackForLater(e) {\n    this.clientHeight = parseInt(e) // 잘 되어야 함!\n}\n\n@extends\nJavaScript 클래스엔 제네릭 기초 클래스를 확장할 때, 매개변수가 어떤 타입이 되어야 하는지 지정할 곳이 없습니다. @extends 태그는 해당 매개변수 타입에 대한 위치를 제공합니다:\n/**\n * @template T\n * @extends {Set}\n */\nclass SortableSet extends Set {\n  // ...\n}\n\n@extends는 클래스에서만 작동한다는 점을 알아두세요. 현재로서는, 생성자 함수가 클래스를 확장하는 방법은 없습니다.\n@enum\n@enum 태그를 사용하면 해당 멤버가 모두 지정된 타입인 객체 리터럴을 생성할 수 있습니다. 대부분의 JavaScript 객체 리터럴과는 다르게, 다른 멤버는 허용되지 않습니다.\n/** @enum {number} */\nconst JSDocState = {\n  BeginningOfLine: 0,\n  SawAsterisk: 1,\n  SavingComments: 2,\n}\n\n@enum은 TypeScript의 enum 과는 꽤 다르며, 훨씬 단순하다는 점에 유의하세요. 그러나 TypeScript의 열거형과는 달리, @enum은 어떠한 타입이든 가질 수 있습니다:\n/** @enum {function(number): number} */\nconst Math = {\n  add1: n => n + 1,\n  id: n => -n,\n  sub1: n => n - 1,\n}\n\n다른 예제들 (More examples)\nvar someObj = {\n  /**\n   * @param {string} param1 - 프로퍼티 할당에 대한 Docs\n   */\n  x: function(param1){}\n};\n\n/**\n * 변수 할당에 대한 docs처럼\n * @return {Window}\n */\nlet someFunc = function(){};\n\n/**\n * 클래스 메서드\n * @param {string} greeting 사용할 인사말\n */\nFoo.prototype.sayHi = (greeting) => console.log(\"Hi!\");\n\n/**\n * 화살표 함수 표현\n * @param {number} x - A multiplier\n */\nlet myArrow = x => x * x;\n\n/**\n * JSX의 무상태 함수 컴포넌트에서도 사용됨.\n * @param {{a: string, b: number}} test - Some param\n */\nvar fc = (test) => {test.a.charAt(0)};\n\n/**\n * 클로저 구문을 사용하여, 매개변수가 클래스 생성자가 될 수 있음.\n *\n * @param {{new(...args: any[]): object}} C - 등록할 클래스\n */\nfunction registerClass(C) {}\n\n/**\n * @param {...string} p1 - A 'rest' arg (array) of strings. ('any'로 취급됨)\n */\nfunction fn10(p1){}\n\n/**\n * @param {...string} p1 - A 'rest' arg (array) of strings. ('any'로 취급됨)\n */\nfunction fn9(p1) {\n  return p1.join();\n}\n\n지원되지 않을 것으로 알려진 패턴들 (Patterns that are known NOT to be supported)\n생성자 함수처럼, 값 공간(value space)에 있는 객체를 타입으로 참조하는 것은 객체가 타입을 생성하지 않는 한 작동하지 않습니다.\nfunction aNormalFunction() {\n\n}\n/**\n * @type {aNormalFunction}\n */\nvar wrong;\n/**\n * 'typeof' 대신 사용:\n * @type {typeof aNormalFunction}\n */\nvar right;\n\n접미사는 객체 리터럴 유형의 프로퍼티 유형과 동일하며 선택적 프로퍼티를 지정하지 않습니다:\n/**\n * @type {{ a: string, b: number= }}\n */\nvar wrong;\n/**\n * 프로퍼티 이름에 물음표 접미사 사용\n * @type {{ a: string, b?: number }}\n */\nvar right;\n\nNullable 타입은 strictNullChecks이 활성화되어있는 때만 의미가 있습니다.\n/**\n * @type {?number}\n * With strictNullChecks: true -- number | null\n * With strictNullChecks: off  -- number\n */\nvar nullable;\n\nNullable이 아닌 타입은 의미가 없으며 원래의 타입으로 취급됩니다:\n/**\n * @type {!number}\n * 단순히 숫자 타입을 갖게 됨\n */\nvar normal;\n\nJSDoc의 타입 시스템과는 다르게, TypeScript는 null 값을 포함하는지, 안 하는지에 대해서만 표시할 수 있습니다.\n명시적인 non-nullability는 없습니다 -- strictNullChecks이 활성화되어 있다면, number는 nullable이 아닐 것입니다.\n활성화되어있지 않다면, number는 nullable 일 것입니다.\n"},"pages/Utility Types.html":{"url":"pages/Utility Types.html","title":"유틸리티 타입","keywords":"","body":"소개 (Introduction)\nTypeScript는 공통 타입 변환을 용이하게 하기 위해 몇 가지 유틸리티 타입을 제공합니다. 이런 유틸리티들은 전역으로 사용 가능합니다.\n목차 (Table of contents)\n\nPartial\nReadonly\nRecord\nPick\nOmit\nExclude\nExtract\nNonNullable\nParameters\nConstructorParameters\nReturnType\nInstanceType\nRequired\nThisParameterType\nOmitThisParameter\nThisType\n\nPartial\nT의 모든 프로퍼티를 선택적으로 만드는 타입을 구성합니다. 이 유틸리티는 주어진 타입의 모든 하위 타입 집합을 나타내는 타입을 반환합니다.\n예제 (Example)\ninterface Todo {\n    title: string;\n    description: string;\n}\n\nfunction updateTodo(todo: Todo, fieldsToUpdate: Partial) {\n    return { ...todo, ...fieldsToUpdate };\n}\n\nconst todo1 = {\n    title: 'organize desk',\n    description: 'clear clutter',\n};\n\nconst todo2 = updateTodo(todo1, {\n    description: 'throw out trash',\n});\n\nReadonly\nT의 모든 프로퍼티를 읽기 전용(readonly)으로 설정한 타입을 구성합니다, 즉 생성된 타입의 프로퍼티는 재할당할 수 없습니다.\n예제 (Example)\ninterface Todo {\n    title: string;\n}\n\nconst todo: Readonly = {\n    title: 'Delete inactive users',\n};\n\ntodo.title = 'Hello'; // 오류: 읽기 전용 프로퍼티에 재할당할 수 없음\n\n이 유틸리티는 런타임에 실패할 할당 표현식을 나타낼 때 유용합니다.(예, frozen 객체의 프로퍼티에 재할당 하려고 하는 경우)\nObject.freeze\nfunction freeze(obj: T): Readonly;\n\nRecord\n타입 T의 프로퍼티의 집합 K로 타입을 구성합니다. 이 유틸리티는 타입의 프로퍼티들을 다른 타입에 매핑시키는 데 사용될 수 있습니다.\n예제 (Example)\ninterface PageInfo {\n    title: string;\n}\n\ntype Page = 'home' | 'about' | 'contact';\n\nconst x: Record = {\n    about: { title: 'about' },\n    contact: { title: 'contact' },\n    home: { title: 'home' },\n};\n\nPick\nT에서 프로퍼티 K의 집합을 선택해 타입을 구성합니다.\n예제 (Example)\ninterface Todo {\n    title: string;\n    description: string;\n    completed: boolean;\n}\n\ntype TodoPreview = Pick;\n\nconst todo: TodoPreview = {\n    title: 'Clean room',\n    completed: false,\n};\n\nOmit\nT에서 모든 프로퍼티를 선택한 다음 K를 제거한 타입을 구성합니다.\n예제 (Example)\ninterface Todo {\n    title: string;\n    description: string;\n    completed: boolean;\n}\n\ntype TodoPreview = Omit;\n\nconst todo: TodoPreview = {\n    title: 'Clean room',\n    completed: false,\n};\n\nExclude\nT에서 U에 할당할 수 있는 모든 속성을 제외한 타입을 구성합니다.\n예제 (Example)\ntype T0 = Exclude;  // \"b\" | \"c\"\ntype T1 = Exclude;  // \"c\"\ntype T2 = Exclude void), Function>;  // string | number\n\nExtract\nT에서 U에 할당 할 수 있는 모든 속성을 추출하여 타입을 구성합니다.\n예제 (Example)\ntype T0 = Extract;  // \"a\"\ntype T1 = Extract void), Function>;  // () => void\n\nNonNullable\nT에서 null 과 undefined를 제외한 타입을 구성합니다.\n예제 (Example)\ntype T0 = NonNullable;  // string | number\ntype T1 = NonNullable;  // string[]\n\nParameters\n함수 타입 T의 매개변수 타입들의 튜플 타입을 구성합니다.\n예제 (Example)\ndeclare function f1(arg: { a: number, b: string }): void\ntype T0 = Parameters string>;  // []\ntype T1 = Parameters void>;  // [string]\ntype T2 = Parameters(arg: T) => T)>;  // [unknown]\ntype T4 = Parameters;  // [{ a: number, b: string }]\ntype T5 = Parameters;  // unknown[]\ntype T6 = Parameters;  // never\ntype T7 = Parameters;  // 오류\ntype T8 = Parameters;  // 오류\n\nConstructorParameters\nConstructorParameters 타입은 생성자 함수 타입의 모든 매개변수 타입을 추출할 수 있게 해줍니다. 모든 매개변수 타입을 가지는 튜플 타입(T가 함수가 아닌 경우 never)을 생성합니다.\n예제 (Example)\ntype T0 = ConstructorParameters;  // [(string | undefined)?]\ntype T1 = ConstructorParameters;  // string[]\ntype T2 = ConstructorParameters;  // [string, (string | undefined)?]\n\nReturnType\n함수 T의 반환 타입으로 구성된 타입을 만듭니다.\n예제 (Example)\ndeclare function f1(): { a: number, b: string }\ntype T0 = ReturnType string>;  // string\ntype T1 = ReturnType void>;  // void\ntype T2 = ReturnType() => T)>;  // {}\ntype T3 = ReturnType() => T)>;  // number[]\ntype T4 = ReturnType;  // { a: number, b: string }\ntype T5 = ReturnType;  // any\ntype T6 = ReturnType;  // any\ntype T7 = ReturnType;  // 오류\ntype T8 = ReturnType;  // 오류\n\nInstanceType\n생성자 함수 타입 T의 인스턴스 타입으로 구성된 타입을 만듭니다.\nExample\nclass C {\n    x = 0;\n    y = 0;\n}\n\ntype T0 = InstanceType;  // C\ntype T1 = InstanceType;  // any\ntype T2 = InstanceType;  // any\ntype T3 = InstanceType;  // 오류\ntype T4 = InstanceType;  // 오류\n\nRequired\nT의 모든 프로퍼티가 필수로 설정된 타입을 구성합니다.\n예제 (Example)\ninterface Props {\n    a?: number;\n    b?: string;\n};\n\nconst obj: Props = { a: 5 }; // 성공\n\nconst obj2: Required = { a: 5 }; // 오류: 프로퍼티 'b'가 없습니다\n\nThisParameterType\n함수 타입의 this 매개변수의 타입, 혹은 함수 타입에 this 매개변수가 없을 경우 unknown을 추출합니다.\n유의: 이 타입은 --strictFunctionTypes가 활성화되었을 때만 올바르게 동작합니다. #32964를 참고하세요.\n예제 (Example)\nfunction toHex(this: Number) {\n    return this.toString(16);\n}\n\nfunction numberToString(n: ThisParameterType) {\n    return toHex.apply(n);\n}\n\nOmitThisParameter\n함수 타입에서 'this' 매개변수를 제거합니다.\n유의: 이 타입은 --strictFunctionTypes가 활성화되었을 때만 올바르게 동작합니다. #32964를 참고하세요.\n예제 (Example)\nfunction toHex(this: Number) {\n    return this.toString(16);\n}\n\n// `bind`의 반환 타입은 이미 `OmitThisParameter`을 사용하고 있습니다, 이는 단지 예제를 위한 것입니다.\nconst fiveToHex: OmitThisParameter = toHex.bind(5);\n\nconsole.log(fiveToHex());\n\nThisType\n이 유틸리티는 변형된 타입을 반환하지 않습니다. 대신, 문맥적 this타입에 표시하는 역할을 합니다. 이 유틸리티를 사용하기 위해선 --noImplicitThis 플래그를 사용해야 한다는 것을 유의하세요.\n예제 (Example)\n// --noImplicitThis 로 컴파일\n\ntype ObjectDescriptor = {\n    data?: D;\n    methods?: M & ThisType;  // 메서드 안의 'this 타입은 D & M 입니다.\n}\n\nfunction makeObject(desc: ObjectDescriptor): D & M {\n    let data: object = desc.data || {};\n    let methods: object = desc.methods || {};\n    return { ...data, ...methods } as D & M;\n}\n\nlet obj = makeObject({\n    data: { x: 0, y: 0 },\n    methods: {\n        moveBy(dx: number, dy: number) {\n            this.x += dx;  // 강하게 타입이 정해진 this\n            this.y += dy;  // 강하게 타입이 정해진 this\n        }\n    }\n});\n\nobj.x = 10;\nobj.y = 20;\nobj.moveBy(5, 5);\n\n위 예제에서, makeObject의 인자로 넘겨지는 methods 객체는 ThisType를 포함한 문맥적 타입을 가지고 있고, 따라서 methods 객체의 메서드 안에 this 타입은{ x: number, y: number } & { moveBy(dx: number, dy: number): number }입니다. method 프로퍼티의 타입이 추론의 대상이며 동시에 메서드 안의 this 타입의 출처인 것을 주목하세요.\nThisType 마커 인터페이스는 단지 lib.d.ts에 선언된 빈 인터페이스입니다. 객체 리터럴의 문맥적 타입으로 인식되는 것을 넘어, 그 인터페이스는 빈 인터페이스처럼 동작합니다.\n"},"pages/declaration files/Introduction.html":{"url":"pages/declaration files/Introduction.html","title":"소개","keywords":"","body":"이 가이드는 고품질의 TypeScript 선언 파일을 작성하는 방법을 알려주기 위해 작성되었습니다.\n이 가이드는, TypeScript 언어에 대한 기본 지식이 있다고 가정합니다.\n만약 기본 지식이 없다면, TypeScript 핸드북을 반드시 읽고\n  기본 개념, 특히 타입과 네임스페이스에 익숙해져야 합니다.\n섹션 (Sections)\n이 가이드는 다음 섹션들로 구성됩니다.\n라이브러리 구조 (Library Structures)\n라이브러리 구조는 일반적인 라이브러리 포맷과 각 포맷에 대한 올바른 선언 파일을 작성하는 방법에 대해 알려줍니다.\n기존 파일을 수정하는 경우라면, 이 섹션을 읽으실 필요는 없습니다.\n새로운 선언 파일을 작성해야 한다면 라이브러리의 포맷이 선언 파일 작성에 어떻게 영향을 미치는지 올바르게 이해하기 위해 반드시 읽어야 합니다.\n예제를 통해 (By Example)\n많은 경우, 기본 라이브러리 예제만 있을 때, 선언 파일을 작성해야 합니다.\n예제를 통해 섹션은 많은 API 패턴들과 각 패턴들의 선언을 작성하는 방법을 보여줍니다.\n이 가이드는 TypeScript의 모든 언어 구성에 아직 익숙하지 않은 TypeScript 초심자에 초점을 맞추고 있습니다.\n해야 할 것과 하지 말아야 할 것 (\"Do\"s and \"Don't\"s)\n선언 파일의 많은 실수들은 쉽게 피할 수 있습니다.\n해야 할 것과 하지 말아야 할 것 섹션은 흔한 오류들을 식별하고,\n  감지하는 방법과,\n  수정하는 방법을 설명합니다.\n흔한 실수들을 피하기 위해 반드시 모두가 이 섹션을 읽어야 합니다.\n깊게 들어가기 (Deep Dive)\n선언 파일이 동작하는 메커니즘에 관심 있는 숙련된 사용자들에게,\n  깊게 들어가기 섹션은 선언 작성의 많은 고급 개념을 설명해 주고,\n  이 개념들을 활용하여 깔끔하고 더 직관적인 선언 파일을 만드는 방법을 보여줍니다.\n템플릿 (Templates)\n템플릿에서는 새로운 파일을 작성할 때, 유용한 시작점을 제공하는\n  여러 선언 파일들을 찾을 수 있습니다.\n라이브러리 구조 문서를 참고하여 어떤 템플릿 파일을 사용할지 알아보세요.\nnpm에 배포하기 (Publish to npm)\n배포 섹션은 선언 파일을 npm 패키지에 배포하는 방법과, 의존성 패키지를 관리하는 방법을 설명합니다.\n선언 파일을 찾고 설치하기 (Find and Install Declaration Files)\nJavaScript 라이브러리 사용자를 위해, 소비 섹션은 해당 선언 파일을 찾고 설치하는 몇 가지 간단한 방법을 제공합니다.\n"},"pages/declaration files/Library Structures.html":{"url":"pages/declaration files/Library Structures.html","title":"Library Structures","keywords":"","body":"개요 (Overview)\n일반적으로, 선언 파일을 구조화하는 방법은 라이브러리를 사용하는 방법에 따라 다릅니다.\nJavaScript에서 사용할 라이브러리를 제공하는 방법은 여러 가지가 있고, 이에 맞추어 선언 파일을 작성해야 합니다.\n이 가이드는 일반적인 라이브러리 패턴을 식별하는 방법과, 그 패턴에 상응하는 선언 파일을 작성하는 방법에 대해 다룹니다.\n주요 라이브러리 각각의 구조화 패턴 유형은 템플릿 섹션에 있습니다.\n이 템플릿으로 시작하면 더 빠르게 진행할 수 있습니다.\n라이브러리 종류 식별하기 (Identifying Kinds of Libraries)\n첫 번째로, TypeScript 선언 파일이 나타낼 수 있는 라이브러리 종류를 다뤄보겠습니다.\n각 종류의 라이브러리를 사용하는 방법과, 작성하는 방법, 그리고 실제 라이브러리들의 예제를 볼 것입니다.\n라이브러리의 구조를 식별하는 것은 선언 파일을 작성하는 첫 단계입니다.\n사용법과 코드를 기반으로 구조를 식별하는 방법에 대한 힌트를 제공합니다.\n라이브러리의 문서와 구성에 따라서, 어떤 건 다른 것보다 훨씬 쉬울 수 있습니다.\n본인에게 더 편한 것을 사용할 것을 추천합니다.\n전역 라이브러리 (Global Libraries)\n전역 라이브러리는 전역 스코프 (즉, import 형식을 사용하지 않음)에서 접근 가능한 라이브러리입니다.\n많은 라이브러리는 사용을 위해 간단히 하나 이상의 전역 변수를 노출합니다.\n예를 들어, jQuery를 사용한다면, $ 변수를 참조해서 사용할 수 있습니다:\n$(() => { console.log('hello!'); } );\n\nHTML 스크립트 태그로 라이브러리를 사용하는 방법은 라이브러리 문서에서 지침을 볼 수 있습니다:\n\n\n오늘날, 대부분의 전역에서 접근 가능한 유명 라이브러리들은 실제로 UMD 라이브러리로 작성되어 있습니다 (아래를 참조).\nUMD 라이브러리 문서는 전역 라이브러리 문서와 구별하기 어렵습니다.\n전역 선언 파일을 작성하기 전에, 실제로는 UMD가 아닌지 확인하십시오.\n코드에서 전역 라이브러리 식별하기 (Identifying a Global Library from Code)\n전역 라이브러리 코드는 대게 엄청 간단합니다.\n전역 \"Hello, world\" 라이브러리는 다음과 같습니다:\nfunction createGreeting(s) {\n    return \"Hello, \" + s;\n}\n\n혹은 다음과 같습니다:\nwindow.createGreeting = function(s) {\n    return \"Hello, \" + s;\n}\n\n전역 라이브러리의 코드를 보면, 보통 다음을 볼 수 있습니다:\n\n최상위 레벨 var문 이나 function선언\n하나 이상의 window.someName 할당\nDOM 인터페이스 document 혹은 window가 존재한다고 가정\n\n다음은 볼 수 없습니다:\n\nrequire 이나 define 같은 모듈 로더 검사 혹은 사용\nvar fs = require(\"fs\"); 형태의 CommonJS/Node.js-스타일 import\ndefine(...) 호출\n라이브러리를 require 혹은 import하는 방법에 대해 설명하는 문서\n\n전역 라이브러리 예제 (Examples of Global Libraries)\n전역 라이브러리를 UMD 라이브러리로 바꾸는게 쉽기 때문에, 전역 스타일로 작성한 인기 라이브러리는 거의 없습니다.\n하지만, 크기가 작고 DOM이 필요한 (혹은 의존성이 없는) 라이브러리는 여전히 전역입니다.\n전역 라이브러리 템플릿 (Global Library Template)\n템플릿 파일 global.d.ts은 예제 라이브러리 myLib를 정의합니다.\n\"이름 충돌 방지\" 각주를 반드시 읽어보세요.\n모듈형 라이브러리 (Modular Libraries)\n어떤 라이브러리는 모듈 로더 환경에서만 동작합니다.\n예를 들어, express는 Node.js에서만 동작하고 반드시 CommonJS의 require 함수로 로드되어야 합니다.\nECMAScript 2015 (ES2015, ECMAScript 6, ES6로도 잘 알려진), CommonJS와 RequireJS는 모듈을 importing하는 비슷한 개념을 가지고 있습니다.\nJavaScript의 CommonJS (Node.js)를 예를 들면, 다음과 같이 작성합니다\nvar fs = require(\"fs\");\n\nTypeScript나 ES6에서는, import 키워드가 같은 목적을 제공합니다:\nimport fs = require(\"fs\");\n\n일반적으로 모듈형 라이브러리의 문서에서 다음 코드들 중 하나를 볼 수 있습니다:\nvar someLib = require('someLib');\n\n혹은\ndefine(..., ['someLib'], function(someLib) {\n\n});\n\n전역 모듈과 마찬가지로 UMD 모듈의 문서에서도 이 예제들을 볼 수 있으므로, 코드나 문서를 반드시 확인하세요.\n코드에서 모듈 라이브러리 식별하기 (Identifying a Module Library from Code)\n모듈형 라이브러리는 일반적으로 다음 중 몇 가지를 반드시 가지고 있습니다:\n\nrequire 혹은 define에 대한 무조건적인 호출\nimport * as a from 'b'; 혹은 export c; 같은 선언문\nexports 혹은 module.exports에 대한 할당\n\n다음은 거의 갖지 않습니다:\n\nwindow 혹은 global 프로퍼티 할당\n\n모듈형 라이브러리 예제 (Examples of Modular Libraries)\n많은 유명한 Node.js 라이브러리들은 express, gulp, request와 같은 모듈군 안에 있습니다.\nUMD\nUMD 모듈은 모듈로 (import를 통해) 사용할 수 있고 혹은 전역으로도 (모듈 로더 없는 환경에서 실행될 때) 사용할 수 있습니다.\nMoment.js 같은 많은 유명한 라이브러리들은 이 방법으로 작성되었습니다.\n예를 들어, Node.js나 RequireJS를 사용하면, 다음과 같이 작성합니다:\nimport moment = require(\"moment\");\nconsole.log(moment.format());\n\n반면 바닐라 브라우저 환경에서는 다음과 같이 쓸 수 있습니다:\nconsole.log(moment.format());\n\nUMD 라이브러리 식별하기 (Identifying a UMD library)\nUMD modules은 모듈 로더 환경 유무를 검사합니다.\n이는 다음과 같이 보이는 찾기 쉬운 패턴입니다:\n(function (root, factory) {\n    if (typeof define === \"function\" && define.amd) {\n        define([\"libName\"], factory);\n    } else if (typeof module === \"object\" && module.exports) {\n        module.exports = factory(require(\"libName\"));\n    } else {\n        root.returnExports = factory(root.libName);\n    }\n}(this, function (b) {\n\n만약 라이브러리 코드, 특히 파일 상단에서 typeof define, typeof window 혹은 typeof module에 대한 테스트를 보았다면, 거의 대부분 UMD 라이브러리입니다.\nUMD 라이브러리 문서에서는 require를 보여주는 \"Node.js에서 사용하기\" 예제를 종종 설명하고\n  \"브라우저에서 사용하기\" 예제에서는  태그를 사용해서 스크립트를 로드하는 방법을 보여줍니다.\nUMD 라이브러리 예제 (Examples of UMD libraries)\n유명한 라이브러리 대부분은 UMD 패키지로 사용할 수 있습니다.\n예로는 jQuery, Moment.js, loadash 등 더 많이 있습니다.\n템플릿 (Template)\n모듈은 세 가지 템플릿을 사용할 수 있습니다,\n  module.d.ts, module-class.d.ts 그리고 module-function.d.ts.\n만약 모듈을 함수처럼 호출할 수 있으면 module-function.d.ts을 사용하세요:\nvar x = require(\"foo\");\n// 참고: 함수로 'x'를 호출\nvar y = x(42);\n\n각주 \"ES6가 모듈 호출 시그니처에 미치는 영향\"를 반드시 읽어보세요\n만약 모듈이 new를 사용하여 생성할 수 있다면 module-class.d.ts를 사용하세요:\nvar x = require(\"bar\");\n// 참고: 'new' 연산자를 import된 변수에 사용\nvar y = new x(\"hello\");\n\n이런 모듈에도 같은 각주가 적용됩니다.\n만약 모듈이 위 사항에 해당되지 않다면, module.d.ts 파일을 사용하세요.\n모듈 플러그인 혹은 UMD 플러그인 (Module Plugin or UMD Plugin)\n모듈 플러그인은 다른 모듈 (UMD나 모듈)의 형태를 변경합니다.\n예를 들어, Moment.js에서, moment-range는 moment 객체에 새로운 range 메서드를 추가합니다.\n선언 파일 작성을 위해, 모듈이 일반 모듈로 변경되든 UMD 모듈로 변경되든 같은 코드를 작성합니다.\n템플릿 (Template)\nmodule-plugin.d.ts 템플릿을 사용하세요.\n전역 플러그인 (Global Plugin)\n전역 플러그인은 전역의 형태를 변경하는 전역 코드입니다.\n전역-수정 모듈과 마찬가지로 런타임에 충돌 가능성을 높입니다.\n예를 들어, 몇몇 라이브러리는 Array.prototype이나 String.prototype에 새로운 함수를 추가합니다.\n전역 플러그인 식별하기 (Identifying global plugins)\n전역 플러그인은 일반적으로 문서를 보고 쉽게 식별할 수 있습니다.\n다음과 같은 예제를 볼 수 있습니다:\nvar x = \"hello, world\";\n// 내장 타입에 새로운 메서드 생성\nconsole.log(x.startsWithHello());\n\nvar y = [1, 2, 3];\n// 내장 타입에 새로운 메서드 생성\nconsole.log(y.reverseAndSort());\n\n템플릿 (Template)\nglobal-plugin.d.ts 템플릿을 사용하세요.\n전역-수정 모듈 (Global-modifying Modules)\n전역-수정 모듈은 import 될 때, 전역 스코프에 존재하는 값을 변경합니다.\n예를 들어, import 될 때 String.prototype에 새로운 멤버를 추가하는 라이브러리가 있을 수 있습니다.\n이 패턴은 런타임 충돌의 가능성 때문에 위험하지만,\n  여전히 선언 파일을 작성할 수 있습니다.\n전역-수정 모듈 식별하기 (Identifying global-modifying modules)\n전역-수정 모듈은 일반적으로 문서를 보고 쉽게 식별할 수 있습니다.\n일반적으로, 전역 플러그인과 비슷하지만, 효과를 활성화하기 위해 require 호출이 필요합니다.\n다음과 같은 문서를 볼 수 있습니다:\n// 반환값을 사용하지 않는 'require' 호출\nvar unused = require(\"magic-string-time\");\n/* 혹은 */\nrequire(\"magic-string-time\");\n\nvar x = \"hello, world\";\n// 내장 타입에 새로운 메서드 생성\nconsole.log(x.startsWithHello());\n\nvar y = [1, 2, 3];\n// 내장 타입에 새로운 메서드 생성\nconsole.log(y.reverseAndSort());\n\n템플릿 (Template)\nglobal-modifying-module.d.ts 템플릿을 사용하세요.\n의존성 사용하기 (Consuming Dependencies)\n라이브러리가 몇 가지 의존성을 가지고 있을 수 있습니다.\n이번 섹션에서는 선언 파일 안에 의존성을 import 하는 방법을 설명합니다.\n전역 라이브러리 의존성 (Dependencies on Global Libraries)\n만약 라이브러리가 전역 라이브러리에 의존성이 있다면, ///  디렉티브를 사용하세요:\n/// \n\nfunction getThing(): someLib.thing;\n\n모듈 의존성 (Dependencies on Modules)\n만약 라이브러리가 모듈에 의존성이 있다면, import문을 사용하세요:\nimport * as moment from \"moment\";\n\nfunction getThing(): moment;\n\nUMD 라이브러리 의존성 (Dependencies on UMD libraries)\n전역 라이브러리에서 (From a Global Library)\n만약 전역 라이브러리가 UMD 모듈에 의존성이 있다면, ///  디렉티브를 사용하세요:\n/// \n\nfunction getThing(): moment;\n\n모듈이나 UMD 라이브러리에서 (From a Module or UMD Library)\n만약 모듈이나 UMD 라이브러리가 UMD 라이브러리에 의존성이 있다면, import문을 사용하세요:\nimport * as someLib from 'someLib';\n\nUMD 라이브러리에 대한 의존성 선언에 ///  디렉티브를 사용하지 마세요!\n각주 (Footnotes)\n이름 충돌 방지하기 (Preventing Name Conflicts)\n전역 선언 파일을 작성할 때, 전역 스코프에 많은 타입을 정의할 수 있다는 점을 유의하세요.\n많은 선언 파일이 프로젝트 내에 있을 때, 해결할 수 없는 이름 충돌이 발생할 수 있으므로 이를 사용하지 않는 것이 좋습니다.\n따라야 하는 간단한 규칙은 라이브러리가 정의한 전역 변수가 무엇이든 타입을 네임스페이스로 정의하는 것입니다.\n예를 들어, 만약 라이브러리가 전역 값 'cats'를 정의하면, 다음과 같이 작성하고\ndeclare namespace cats {\n    interface KittySettings { }\n}\n\n이렇게 하지는 마세요\n// 최상위-레벨에서\ninterface CatsKittySettings { }\n\n이 가이드는 선언 파일 사용자가 중단하지 않고 라이브러리를 UMD로 전환할 수 있도록 합니다.\nES6가 모듈 플러그인에 미치는 영향 (The Impact of ES6 on Module Plugins)\n어떤 플러그인은 기존 모듈에 최상위 export를 추가하거나 수정합니다.\nCommonJS와 다른 로더에서는 허용되지만, ES6 모듈은 불변하다고 간주되기에 이 패턴은 불가능합니다.\n왜냐하면 TypeScript는 로더에 구애받지 않기에, 이 정책이 컴파일-시간에 적용되지 않지만, ES6 모듈 로더로 전환하려는 개발자는 알고 있어야 합니다.\n모듈 호출 시그니처에 ES6가 미치는 영향 (The Impact of ES6 on Module Call Signatures)\nExpress와 같은 많은 유명한 라이브러리들은 import 될 때 호출 가능한 함수를 노출합니다.\n예를 들어, 일반적인 Express 사용법은 다음과 같습니다:\nimport exp = require(\"express\");\nvar app = exp();\n\nES6 모듈 로더에서, 최상위-레벨 객체(여기에서는 exp로 import)는 프로퍼티만 가질 수 있습니다;\n  최상위-레벨 모듈 객체는 절대 호출할 수 없습니다.\n가장 일반적인 해결책은 호출 가능/생성 가능 객체를 default export로 정의하는 것입니다;\n  어떤 모듈 로더 shims은 자동으로 이 상황을 감지하고 최상위-레벨 객체를 default export로 바꿉니다.\n라이브러리 파일 레이아웃 (Library file layout)\n선언 파일의 레이아웃은 라이브러리의 레이아웃을 반영해야 합니다.\n라이브러리는 다음과 같이 여러 모듈로 구성됩니다\nmyLib\n  +---- index.js\n  +---- foo.js\n  +---- bar\n         +---- index.js\n         +---- baz.js\n\n이는 다음과 같이 import 할 수 있습니다\nvar a = require(\"myLib\");\nvar b = require(\"myLib/foo\");\nvar c = require(\"myLib/bar\");\nvar d = require(\"myLib/bar/baz\");\n\n그러므로 선언 파일은 다음과 같아야 합니다\n@types/myLib\n  +---- index.d.ts\n  +---- foo.d.ts\n  +---- bar\n         +---- index.d.ts\n         +---- baz.d.ts\n\n"},"pages/declaration files/By Example.html":{"url":"pages/declaration files/By Example.html","title":"By Example","keywords":"","body":"소개 (Introduction)\n이 가이드는 양질의 선언 파일을 작성하는 방법을 설명하기 위해 작성되었습니다.\n이 가이드는 일부 API 문서를 해당 API 사용 예시와 함께 보여주고,\n  상응하는 선언을 작성하는 방법을 설명합니다.\n예제는 대체로 후반부로 갈수록 복잡해집니다.\n\n전역 변수 (Global Variables)\n전역 함수 (Global Functions)\n프로퍼티를 갖는 객체 (Objects with Properties)\n오버로드된 함수 (Overloaded Function)\n재사용 가능한 타입 (인터페이스) (Reusable Types (Interfaces))\n재사용 가능한 타입 (타입 별칭) (Reusable Types (Type Aliases))\n타입 구조화하기 (Organizing Types)\n클래스 (Classes)\n\n예제 (The Examples)\n전역 변수 (Global Variables)\n문서\n\n전역 변수 foo는 존재하는 위젯의 수를 포함합니다.\n\n코드\nconsole.log(\"Half the number of widgets is \" + (foo / 2));\n\n선언\n변수를 선언하기 위해 declare var를 사용하세요.\n만약 변수가 읽기-전용이라면, declare const를 사용하세요.\n변수가 블록-스코프인 경우 declare let 또한 사용할 수 있습니다.\n/** 존재하는 위젯의 수 */\ndeclare var foo: number;\n\n전역 함수 (Global Functions)\n문서\n\n사용자에게 인사말을 보여주기 위해 greet 함수를 호출할 수 있습니다.\n\n코드\ngreet(\"hello, world\");\n\n선언\n함수를 선언하기 위해 declare function을 사용하세요.\ndeclare function greet(greeting: string): void;\n\n프로퍼티를 갖는 객체 (Objects with Properties)\n문서\n\n전역 변수 myLib에는 인사말을 만드는 함수 makeGreeting와,\n지금까지 생성한 인사말의 수를 가리키는 numberOfGreetings 프로퍼티가 있습니다.\n\n코드\nlet result = myLib.makeGreeting(\"hello, world\");\nconsole.log(\"The computed greeting is:\" + result);\n\nlet count = myLib.numberOfGreetings;\n\n선언\n점 표기법으로 접근하는 타입이나 값을 설명하기 위해 declare namespace를 사용하세요.\ndeclare namespace myLib {\n    function makeGreeting(s: string): string;\n    let numberOfGreetings: number;\n}\n\n오버로드된 함수 (Overloaded Functions)\n문서\ngetWidget 함수는 숫자를 인자로 받아 Widget을 반환하거나, 문자열을 인자로 받아 Widget 배열을 반환합니다.\n코드\nlet x: Widget = getWidget(43);\n\nlet arr: Widget[] = getWidget(\"all of them\");\n\n선언\ndeclare function getWidget(n: number): Widget;\ndeclare function getWidget(s: string): Widget[];\n\n재사용 가능한 타입 (인터페이스) (Reusable Types (Interfaces))\n문서\n\ngreeting을 명시할 때, 반드시 GreetingSettings 객체를 전달해야 합니다.\n이 객체는 다음의 프로퍼티를 갖고 있습니다:\n1 - greeting: 필수 문자열\n2 - duration: 선택적 시간 (밀리초)\n3 - color: 선택적 문자열, 예. '#ff00ff'\n\n코드\ngreet({\n  greeting: \"hello world\",\n  duration: 4000\n});\n\n선언\n프로퍼티를 갖는 타입을 정의하기 위해 interface를 사용하세요.\ninterface GreetingSettings {\n  greeting: string;\n  duration?: number;\n  color?: string;\n}\n\ndeclare function greet(setting: GreetingSettings): void;\n\n재사용 가능한 타입 (타입 별칭) (Reusable Types (Type Aliases))\n문서\n\n인사말이 예상되는 어느 곳에나, string, string을 반환하는 함수, 또는 Greeter 인스턴스를 전달할 수 있습니다.\n\n코드\nfunction getGreeting() {\n    return \"howdy\";\n}\nclass MyGreeter extends Greeter { }\n\ngreet(\"hello\");\ngreet(getGreeting);\ngreet(new MyGreeter());\n\n선언\n타입에 대한 약칭으로 타입 별칭을 사용할 수 있습니다:\ntype GreetingLike = string | (() => string) | Greeter;\n\ndeclare function greet(g: GreetingLike): void;\n\n타입 구조화하기 (Organizing Types)\n문서\n\ngreeter 객체는 파일에 로그를 작성하거나 경고 창을 띄울 수 있습니다.\n로그 옵션을 .log(...) 내부에, 경고 창 옵션을 .alert(...) 내부에 전달할 수 있습니다.\n\n코드\nconst g = new Greeter(\"Hello\");\ng.log({ verbose: true });\ng.alert({ modal: false, title: \"Current Greeting\" });\n\n선언\n타입을 구조화하기 위해 네임스페이스를 사용하세요.\ndeclare namespace GreetingLib {\n    interface LogOptions {\n        verbose?: boolean;\n    }\n    interface AlertOptions {\n        modal: boolean;\n        title?: string;\n        color?: string;\n    }\n}\n\n중첩된 네임스페이스를 하나의 선언으로 만들 수 있습니다:\ndeclare namespace GreetingLib.Options {\n    // Refer to via GreetingLib.Options.Log\n    interface Log {\n        verbose?: boolean;\n    }\n    interface Alert {\n        modal: boolean;\n        title?: string;\n        color?: string;\n    }\n}\n\n클래스 (Classes)\n문서\n\nGreeter 객체를 인스턴스화해서 greeter를 생성하거나, 이 객체를 상속해서 커스텀 greeter를 생성할 수 있습니다.\n\n코드\nconst myGreeter = new Greeter(\"hello, world\");\nmyGreeter.greeting = \"howdy\";\nmyGreeter.showGreeting();\n\nclass SpecialGreeter extends Greeter {\n    constructor() {\n        super(\"Very special greetings\");\n    }\n}\n\n선언\n클래스 혹은 클래스-같은 객체를 설명하기 위해 declare class를 사용하세요.\n클래스는 생성자 뿐만 아니라 프로퍼티와 메서드를 가질 수 있습니다.\ndeclare class Greeter {\n    constructor(greeting: string);\n\n    greeting: string;\n    showGreeting(): void;\n}\n\n\n\n*Code*\n\n```ts\n\n```\n\n*Declaration*\n\n```ts\n\n```\n\n-->\n"},"pages/declaration files/Do's and Don'ts.html":{"url":"pages/declaration files/Do's and Don'ts.html","title":"Do's and Don'ts","keywords":"","body":"일반 타입 (General Types)\nNumber, String, Boolean, Symbol and Object\nNumber, String, Boolean, Symbol, Object 타입을 사용하지 마세요.\n이 타입들은 JavaScript 코드에서 거의 사용되지 않는 비-원시형 박싱된 객체를 가르킵니다.\n/* 잘못됨 */\nfunction reverse(s: String): String;\n\nnumber, string, boolean, symbol 타입을 사용 하세요.\n/* 좋음 */\nfunction reverse(s: string): string;\n\nObject 대신에, TypeScript 2.2 에 추가된 비-원시형 object타입을 사용하세요.\n제네릭 (Generics)\n타입 매개변수를 사용하지 않는 제네릭 타입을 사용하지 마세요. 더 자세한 내용은 TypeScript FAQ 페이지에서 확인하세요.\n\n콜백 타입 (Callback Types)\n콜백의 반환 타입 (Return Types of Callbacks)\n\n사용하지 않는 콜백의 반환 값 타입에 any를 사용하지 마세요:\n/* 잘못됨 */\nfunction fn(x: () => any) {\n    x();\n}\n\n사용하지 않는 콜백의 반환 값 타입은 void를 사용하세요:  \n/* 좋음 */\nfunction fn(x: () => void) {\n    x();\n}\n\n이유: void를 사용하면 실수로 x의 반환 값을 사용하는 것을 방지 할 수 있기 때문에 더 안전합니다.:\nfunction fn(x: () => void) {\n    var k = x(); // oops! meant to do something else\n    k.doSomething(); // error, but would be OK if the return type had been 'any'\n}\n\n콜백에서 선택적 매개변수 (Optional Parameters in Callbacks)\n정말 의도한 것이 아니라면 콜백에 선택적 매개변수를 사용하지 마세요:\n/* 잘못됨 */\ninterface Fetcher {\n    getObject(done: (data: any, elapsedTime?: number) => void): void;\n}\n\n이는 아주 구체적인 의미를 가지고 있습니다: done 콜백은 1개 혹은 2개의 인자로 호출될 수 있습니다.\n작성자는 아마 elapsedTime 매개변수가 콜백에 상관없다는 것을 말하려는 의도였을 것입니다,\n  하지만 이를 위해 매개변수를 선택적으로 만들 필요는 없습니다 --\n  콜백에 더 적은 인수를 제공하는 것은 항상 허용됩니다.\n콜백 매개변수를 비-선택적으로 작성하세요:\n/* 좋음 */\ninterface Fetcher {\n    getObject(done: (data: any, elapsedTime: number) => void): void;\n}\n\n오버로드와 콜백 (Overloads and Callbacks)\n콜백의 인수만 다른 오버로드를 분리해서 작성 하지 마세요:\n/* 잘못됨 */\ndeclare function beforeAll(action: () => void, timeout?: number): void;\ndeclare function beforeAll(action: (done: DoneFn) => void, timeout?: number): void;\n\n최대 인수를 사용해 하나의 오버로드를 작성 하세요:\n/* 좋음 */\ndeclare function beforeAll(action: (done: DoneFn) => void, timeout?: number): void;\n\n이유: 콜백이 매개변수를 무시하는 것은 항상 허용되므로, 짧은 오버로드는 필요하지 않습니다.\n더 짧은 콜백을 먼저 작성하면 넘어오는 함수가 첫 번째 오버로드와 일치하기 때문에 잘못된-타입의 함수를 허용합니다.\n함수 오버로드 (Function Overloads)\n순서 (Ordering)\n더 일반적인 오버로드를 더 구체적인 오버로드 이전에 두지 마세요:\n/* 잘못됨 */\ndeclare function fn(x: any): any;\ndeclare function fn(x: HTMLElement): number;\ndeclare function fn(x: HTMLDivElement): string;\n\nvar myElem: HTMLDivElement;\nvar x = fn(myElem); // x: any, wat?\n\n구체적인 오버로드 뒤에 일반적인 오버로드가 위치하게 정렬 하세요:\n/* 좋음 */\ndeclare function fn(x: HTMLDivElement): string;\ndeclare function fn(x: HTMLElement): number;\ndeclare function fn(x: any): any;\n\nvar myElem: HTMLDivElement;\nvar x = fn(myElem); // x: string, :)\n\n이유: TypeScript는 함수 호출을 처리할 때 첫 번째로 일치하는 오버로드를 선택합니다.\n이전의 오버로드가 뒤에 것보다 \"더 구체적\"이면, 뒤에 것은 사실상 가려져 호출되지 않습니다.\n선택적 매개변수 사용 (Use Optional Parameters)\n뒤따라오는 매개변수만 다른 오버로드를 작성하지 마세요:\n/* 잘못됨 */\ninterface Example {\n    diff(one: string): number;\n    diff(one: string, two: string): number;\n    diff(one: string, two: string, three: boolean): number;\n}\n\n가능한 선택적 매개변수를 사용 하세요:\n/* 좋음 */\ninterface Example {\n    diff(one: string, two?: string, three?: boolean): number;\n}\n\n이 문제는 모든 오버로드가 같은 반환 타입을 가질 때만 발생한다는 점에 유의하세요.\n이유: 두 가지 중요한 이유가 있습니다.\nTypeScript는 소스의 인수로 대상의 시그니처를 호출할 수 있는지 확인하여 시그니처 호환성을 결정합니다.\n  그리고 관계없는 인수가 허용됩니다\n예를 들어, 이 코드는 선택적 매개변수를 사용하여 올바르게 작성된 경우에만 버그를 노출합니다:\nfunction fn(x: (a: string, b: number, c: number) => void) { }\nvar x: Example;\n// 오버로드로 작성한 경우, OK -- 첫번째 오버로드가 사용됨\n// 선택적으로 작성한 경우, 올바르게 오류.\nfn(x.diff);\n\n두 번째 이유는 사용자가 TypeScript의 \"strict null checking\" 기능을 사용할 때입니다.\nJavaScript에서 지정되지 않은 매개변수는 undefined로 나타나기 때문에, 일반적으로 선택적 매개변수가 있는 함수에 명시적으로 undefined를 전달하는 것이 좋습니다.\n예를 들어, 이 코드는, strict null에서 문제없습니다.\nvar x: Example;\n// 오버로드로 작성한 경우, `undefined`를 `string` 에 전달했기 때문에 잘못된 에러\n// 선택적으로 작성한 경우, 올바름\nx.diff(\"something\", true ? undefined : \"hour\");\n\n유니언 타입 사용 (Use Union Types)\n한 인수 위치에서 타입만 다른 오버로드를 사용하지 마세요:\n/* 잘못됨 */\ninterface Moment {\n    utcOffset(): number;\n    utcOffset(b: number): Moment;\n    utcOffset(b: string): Moment;\n}\n\n가능한 유니언 타입을 사용 하세요:\n/* 좋음 */\ninterface Moment {\n    utcOffset(): number;\n    utcOffset(b: number|string): Moment;\n}\n\n시그니처의 반환 타입이 다르기 때문에 b를 선택적으로 만들지 않은 점에 유의하세요.\n이유: 이는 함수에 값을 \"전달하는\" 사람들에게 중요합니다.:\nfunction fn(x: string): void;\nfunction fn(x: number): void;\nfunction fn(x: number|string) {\n    // 분리된 오버로드로 작성된 경우, 잘못된 에러\n    // 유니언 타입으로 작성된 경우, 올바름\n    return moment().utcOffset(x);\n}\n\n"},"pages/declaration files/Deep Dive.html":{"url":"pages/declaration files/Deep Dive.html","title":"Deep Dive","keywords":"","body":"정의 파일 이론: 심층 분석 (Definition File Theory: A Deep Dive)\n원하는 API 형태를 제공하는 모듈을 만드는 것은 까다로울 수 있습니다.\n예를 들어, new의 사용에 따라 호출할 때 다른 타입을 생성하는 모듈을 원할 수 있고,\n  계층에 노출 된 다양한 명명된 타입을 가지고 있으며,\n  모듈 객체에 대한 여러 프로퍼티도 가질 수 있습니다.\n이 가이드에서는, 익숙한 API를 노출하는 복잡한 정의 파일에 대해 작성하는 도구를 제공합니다.\n또한 옵션이 다양하기 때문에 여기서는 모듈 (또는 UMD) 라이브러리에 중점을 둡니다.\n주요 컨셉 (Key Concepts)\nTypeScript 작동 방식에 대해 여러 주요 개념을 이해하여\n  정의의 형태를 만드는 방법을 완전히 이해할 수 있습니다.\n타입 (Types)\n이 가이드를 읽고 있다면, 아마도 TypeScript의 타입에 대해 이미 알고 있을 것입니다.\n보다 명확하게하기 위해, 다음과 같이 타입이 도입됩니다:\n\n타입 별칭 선언 (type sn = number | string;)\n인터페이스 선언 (interface I { x: number[]; })\n클래스 선언 (class C { })\n열거형 선언 (enum E { A, B, C })\n타입을 가리키는 import 선언\n\n이러한 각 선언 형태는 새로운 타입 이름을 만듭니다.\n값 (Values)\n타입과 마찬가지로 값이 무엇인지 이미 알고 있을 것입니다.\n값은 표현식에서 참조할 수 있는 런타임 이름입니다.\n예를 들어 let x = 5;에서는 x라고 불리는 값을 생성합니다.\n다시 명확하게 말하자면, 다음과 같이 값을 만듭니다:\n\nlet, const, 그리고 var 선언\n값을 포함하는 네임스페이스 또는 모듈 선언\n열거형 선언\n클래스 선언\n값을 참조하는 import 선언\n함수 선언\n\n네임스페이스 (Namespaces)\n타입은 네임스페이스 안에 존재할 수 있습니다.\n예를 들어, let x: A.B.C 이란 선언이 있다면,\n  타입 C는 A.B 네임스페이스에서 온 것 입니다.\n이 구별은 미묘하지만 중요합니다 -- 여기서 A.B는 타입이거나 값일 필요는 없습니다.\n간단한 조합: 하나의 이름, 여러 의미 (Simple Combinations: One name, multiple meanings)\nA라는 이름이 있으면, A에 대해 타입, 값 또는 네임스페이스라는 세 가지 다른 의미를 찾을 수 있습니다.\n이름을 해석하는 방법은 사용하는 컨텍스트에 따라 다릅니다.\n예를 들어 let m: A.A = A; 선언에서,\n  A는 먼저 네임스페이스로 사용 된 다음, 타입의 이름으로, 그 다음 값으로 사용됩니다.\n즉 완전히 다른 선언을 의미할 수 있습니다!\n약간은 혼란스러워 보이지만, 과하게 사용하지 않는 한 실제로 매우 편리합니다.\n결합 동작의 유용한 측면을 살펴 보겠습니다.\n내부 조합 (Built-in Combinations)\n영리한 사람이라면, 타입과 값 목록에서 클래스가 둘 다 나온 것을 눈치챘을 것입니다.\nclass C { } 선언은 두 가지를 만듭니다:\n  클래스 인스턴스의 형태를 나타내는 타입 C와\n  클래스 생성자를 나타내는 값 C 입니다.\n열거형 선언도 비슷하게 동작합니다.\n사용자 조합 (User Combinations)\n모듈 파일 foo.d.ts을 작성했습니다:\nexport var SomeVar: { a: SomeType };\nexport interface SomeType {\n  count: number;\n}\n\n그 다음 사용했습니다:\nimport * as foo from './foo';\nlet x: foo.SomeType = foo.SomeVar.a;\nconsole.log(x.count);\n\n잘 작동하지만, SomeType과 SomeVar는 이름이 같도록\n  밀접하게 관련되어 있다고 상상할 수 있습니다.\n결합을 사용하여 같은 이름 Bar로 두 가지 다른 객체 (값과 타입)를 표시 할 수 있습니다:\nexport var Bar: { a: Bar };\nexport interface Bar {\n  count: number;\n}\n\n이 경우 사용하는 코드를 구조 분해할 수 있는 아주 좋은 기회입니다:\nimport { Bar } from './foo';\nlet x: Bar = Bar.a;\nconsole.log(x.count);\n\n여기서도 Bar를 타입과 값으로 사용했습니다.\nBar 값을 Bar 타입으로 선언할 필요가 없다는 점을 유의하세요 -- 저 둘은 독립적입니다.\n고급 결합 (Advanced Combinations)\n선언은 여러 개의 선언에 걸쳐 결합될 수 있습니다.\n예를 들어, class C { }와 interface C { } 같이 결합할 수 있으며 둘 다 C 타입에 프로퍼티를 추가합니다.\n충돌을 일으키지 않는다면 충분히 합법적입니다.\n일반적인 경험 법칙은 값의 이름이 네임스페이스로 선언되지 않는 한 항상 같은 이름의 다른 값과 충돌하고,\n  타입 별칭 선언(type s = string)으로 선언 된 경우 타입이 충돌하며,\n  네임스페이스와는 절대로 충돌하지 않는 것입니다.\n어떻게 사용되는지 살펴보겠습니다.\n인터페이스를 사용하여 추가하기 (Adding using an interface)\n인터페이스에 다른 인터페이스 선언을 사용하여 멤버를 추가할 수 있습니다:\ninterface Foo {\n  x: number;\n}\n// ... 다른 위치 ...\ninterface Foo {\n  y: number;\n}\nlet a: Foo = ...;\nconsole.log(a.x + a.y); // 성공\n\n클래스와도 같이 동작합니다:\nclass Foo {\n  x: number;\n}\n// ... 다른 위치 ...\ninterface Foo {\n  y: number;\n}\nlet a: Foo = ...;\nconsole.log(a.x + a.y); // 성공\n\n단, 타입 별칭 (type s = string;)에는 인터페이스를 사용해서 추가할 수 없습니다.\n네임스페이스를 사용하여 추가하기 (Adding using a namespace)\n네임스페이스 선언은 충돌을 일으키지 않는 방식으로 새로운 타입, 값 그리고 네임스페이스를 추가할 수 있습니다.\n예를 들어, 클래스에 정적 멤버를 추가할 수 있습니다:\nclass C {\n}\n// ... 다른 위치 ...\nnamespace C {\n  export let x: number;\n}\nlet y = C.x; // 성공\n\n위 예제에서 C의 정적 측면(생성자 함수)에 값을 추가했습니다.\n값을 추가 했고 모든 값에 대한 컨테이너가 다르기 때문입니다.\n  (타입은 네임스페이스에 포함되고 네임스페이스는 다른 네임스페이스에 포함됩니다).\n네임스페이스 타입을 클래스에 추가할 수 있습니다:\nclass C {\n}\n// ... 다른 위치 ...\nnamespace C {\n  export interface D { }\n}\nlet y: C.D; // 성공\n\n이 예제에서 namespace 선언을 작성할 때까지 네임스페이스 C는 없었습니다.\n네임스페이스 C는 클래스에 의해 생성된 C의 값 또는 타입과 충돌하지 않습니다.\n마지막으로 namespace 선언을 사용하여 다양한 병합을 할 수 있습니다.\n특히 현실적인 예는 아니지만, 흥미로운 동작을 확인할 수 있습니다:\nnamespace X {\n  export interface Y { }\n  export class Z { }\n}\n\n// ... 다른 위치 ...\nnamespace X {\n  export var Y: number;\n  export namespace Z {\n    export class C { }\n  }\n}\ntype X = string;\n\n위 예제에서 첫 번째 블록은 다음 이름의 의미를 만듭니다:\n\n값 X (네임스페이스 선언은 값 Z를 포함하기 때문입니다)\n네임스페이스 X (네임스페이스 선언은 타입 Y를 포함하기 때문입니다)\nX 네임스페이스 안의 타입 Y\nX 네임스페이스 안의 타입 Z (클래스의 인스턴스 형태)\nX 값의 프로퍼티인 값 Z (클래스의 생성자 함수)\n\n두 번째 블록은 다음 이름의 의미를 만듭니다:\n\nX 값의 프로퍼티인 값 Y (number 타입)\n네임스페이스 Z\nX 값의 프로퍼티인 값 Z\nX.Z 네임스페이스 안의 타입 C\nX.Z 값의 프로퍼티인 값 C\n타입 X\n\nexport = or import 사용하기 (Using with export = or import)\n중요한 규칙은 export와 import 선언이 대상의 모든 의미 를 내보내거나 가져온다는 것 입니다.\n\n"},"pages/declaration files/Templates.html":{"url":"pages/declaration files/Templates.html","title":"Templates","keywords":"","body":"\nglobal-modifying-module.d.ts\nglobal-plugin.d.ts\nglobal.d.ts\nmodule-class.d.ts\nmodule-function.d.ts\nmodule-plugin.d.ts\nmodule.d.ts\n\n"},"pages/declaration files/Publishing.html":{"url":"pages/declaration files/Publishing.html","title":"Publishing","keywords":"","body":"이 가이드를 따라 선언 파일을 작성했으므로, 이제 npm에 배포할 시간입니다.\nnpm에 선언 파일을 배포하는 방법은 크게 두 가지가 있습니다:\n\nnpm 패키지로 번들링하거나\nnpm의 @types organization에 배포하기\n\n만약 패키지가 TypeScript로 작성되었다면 첫 번째 방법을 사용하는 것이 좋습니다.\n--declaration 플래그를 사용하여 선언 파일을 생성하세요.\n이 방법을 사용하면, 선언과 JavaScript가 항상 일치하게 됩니다.\n만약 패키지가 TypeScript로 작성되지 않았다면 두 번째 방법을 사용하는 것이 좋습니다.\nnpm 패키지에 선언 포함하기 (Including declarations in your npm package)\n만약 패키지가 메인 .js 파일을 가지고 있다면, 메인 선언 파일을 package.json에도 표시해야 합니다.\n번들링된 선언 파일을 types 프로퍼티로 가리키도록 하세요.\n예를 들어:\n{\n    \"name\": \"awesome\",\n    \"author\": \"Vandelay Industries\",\n    \"version\": \"1.0.0\",\n    \"main\": \"./lib/main.js\",\n    \"types\": \"./lib/main.d.ts\"\n}\n\n\"typings\" 필드는 \"types\"와 동의어이기 때문에 역시 사용할 수 있습니다.\n또한 package.json이 \"files\" 프로퍼티를 포함하고 있으면 \"types\" 프로퍼티는 무시됩니다. 이 경우 메인 선언 파일을 \"files\" 프로퍼티에 전달해야 합니다.\n만약 메인 선언 파일 이름이 index.d.ts이고 패키지의 루트에 있으면 (index.js 옆에) \"types\" 프로퍼티를 쓰지 않아도 되지만, 쓰는 것이 좋습니다.\n의존성 (Dependencies)\n모든 의존성은 npm으로 관리됩니다.\n의존성이 있는 모든 선언 패키지가 package.json에 \"dependencies\" 섹션 안에 알맞게 작성되어 있는지 확인하세요.\n예를 들어, Browserify와 TypeScript로 작성된 패키지를 생각해봅시다.\n{\n    \"name\": \"browserify-typescript-extension\",\n    \"author\": \"Vandelay Industries\",\n    \"version\": \"1.0.0\",\n    \"main\": \"./lib/main.js\",\n    \"types\": \"./lib/main.d.ts\",\n    \"dependencies\": {\n        \"browserify\": \"latest\",\n        \"@types/browserify\": \"latest\",\n        \"typescript\": \"next\"\n    }\n}\n\n여기에서, 패키지는 browserify와 typescript 패키지에 의존성이 있습니다.\nbrowserify는 선언 파일이 npm 패키지에 함께 번들링 되지 않기 때문에, @types/browserify 선언을 의존성에 추가해야 합니다.\n반면에 typescript는 선언 파일이 패키징되기 때문에, 별도의 의존성을 추가할 필요가 없습니다.\n이 패키지는 browserify와 typescript 패키지의 각 선언을 노출하기 때문에, browserify-typescript-extension 패키지는 이 의존성들을 가져야 합니다.\n이 이유로, \"devDependencies\"가 아니라 \"dependencies\"를 사용합니다. 왜냐하면 \"devDependencies\"를 사용하면 사용자가 직접 이 패키지들을 설치해야 하기 때문입니다.\n만약에 단지 명령줄 애플리케이션을 작성했고 패키지를 라이브러리로 사용하길 기대하지 않는다면, devDependencies를 사용해도 됩니다.\n경고 플래그 (Red flags)\n/// \n선언 파일에 /// 를 사용하지 마세요.\n/// \n....\n\n대신 /// 를 사용하세요.\n/// \n....\n\n더 자세한 내용을 위해 의존성 사용하기 섹션을 다시 보십시오.\n의존적인 선언 패키징하기 (Packaging dependent declarations)\n만약 타입 정의가 다른 패키지에 의존적이라면:\n\n각 파일은 유지하고 다른 패키지와 합치지 마세요.\n또한 작성한 패키지에 선언을 복사하지 마세요.\n만약 npm 타입 선언 패키지가 선언 파일을 패키징하지 않는다면, 해당 패키지에 의존하세요.\n\n@types에 배포하기 (Publish to @types)\n@types안에 있는 패키지들은 타입-배포 도구를 사용하여 DefinitelyTyped에서 자동으로 배포되었습니다.\n선언을 @types 패키지로 배포하려면, https://github.com/DefinitelyTyped/DefinitelyTyped에 pull request를 제출하세요.\n기여 지침 페이지에서 더 자세한 내용을 찾을 수 있습니다.\n"},"pages/declaration files/Consumption.html":{"url":"pages/declaration files/Consumption.html","title":"Consumption","keywords":"","body":"TypeScript 2.0에서는 선언 파일을 얻고, 사용하고, 찾는 것이 훨씬 쉬워졌습니다.\n이 페이지에서 세 가지를 어떻게 하는지 정확하게 설명합니다.\n다운로드 (Downloading)\nTypeScript 2.0 이상에서 타입 선언을 가져오는데 npm 이외의 도구는 필요하지 않습니다.\n예를 들어, lodash와 같은 라이브러리에 대한 선언을 얻는 것은 다음 명령어로 충분합니다.\nnpm install --save @types/lodash\n\nPublishing에서 설명한 데로 npm 패키지에 이미 선언 파일이 포함되어 있다면, @types 패키지를 설치할 필요는 없다는 걸 유의하세요.\n사용하기 (Consuming)\nTypeScript 코드에 별 어려움 없이 lodash를 사용할 수 있습니다.\n이는 모듈 및 전역 코드에 모두 적용됩니다.\n예를 들어, 타입 선언에 대해 npm install을 한 번만 수행하면, import 하고 사용할 수 있고\nimport * as _ from \"lodash\";\n_.padStart(\"Hello TypeScript!\", 20, \" \");\n\n또는 모듈을 사용하지 않는다면, 전역 변수 _ 를 사용할 수 있습니다.\n_.padStart(\"Hello TypeScript!\", 20, \" \");\n\n찾기 (Searching)\n대부분의 경우, 타입 선언 패키지 이름은 항상 npm 상의 패키지 이름과 같아야 하지만, @types/ 가 앞에 붙어야 합니다.\n  하지만 필요시 https://aka.ms/types 를 방문해 선호하는 라이브러리의 패키지를 찾으세요.\n\n참고: 만약 찾고자 하는 선언 파일이 없는 경우, 언제든지 기여하고, 다음 개발자가 이를 찾는 데 도움을 줄 수 있습니다.\n자세한 내용은 DefinitelyTyped의 기여 지침 페이지를 참고하세요.\n\n"},"pages/tsconfig.json.html":{"url":"pages/tsconfig.json.html","title":"tsconfig.json","keywords":"","body":"개요\n디렉토리에 tsconfig.json 파일이 존재한다는 것은 해당 디렉토리가 TypeScript 프로젝트의 루트임을 나타냅니다.tsconfig.json 파일은 프로젝트를 컴파일하는 데 필요한 루트 파일과 컴파일러 옵션을 지정합니다.\n프로젝트는 다음 방법 중 하나로 컴파일됩니다:\ntsconfig.json 사용\n\n입력 파일 없이 tsc를 호출하는 경우 컴파일러는 현재 디렉토리에서부터 시작하여 상위 디렉토리 체인으로 이어지며 tsconfig.json 파일을 검색합니다.\n입력 파일이 없는 tsc와 tsconfig.json 파일이 포함된 디렉토리의 경로를 지정하는 --project (또는 -p) 커맨드 라인 옵션을 호출하거나 유효한 경로의 .json 파일에 설정이 포함되어 있습니다.\n\n커맨드 라인에 입력 파일을 지정하면 tsconfig.json 파일이 무시됩니다.\n예제\ntsconfig.json 예제 파일들:\n\n\"files\" 속성 사용\n{\n    \"compilerOptions\": {\n        \"module\": \"commonjs\",\n        \"noImplicitAny\": true,\n        \"removeComments\": true,\n        \"preserveConstEnums\": true,\n        \"sourceMap\": true\n    },\n    \"files\": [\n        \"core.ts\",\n        \"sys.ts\",\n        \"types.ts\",\n        \"scanner.ts\",\n        \"parser.ts\",\n        \"utilities.ts\",\n        \"binder.ts\",\n        \"checker.ts\",\n        \"emitter.ts\",\n        \"program.ts\",\n        \"commandLineParser.ts\",\n        \"tsc.ts\",\n        \"diagnosticInformationMap.generated.ts\"\n    ]\n}\n\n\n\"include\" 및 \"exclude\" 속성 사용\n{\n    \"compilerOptions\": {\n        \"module\": \"system\",\n        \"noImplicitAny\": true,\n        \"removeComments\": true,\n        \"preserveConstEnums\": true,\n        \"outFile\": \"../../built/local/tsc.js\",\n        \"sourceMap\": true\n    },\n    \"include\": [\n        \"src/**/*\"\n    ],\n    \"exclude\": [\n        \"node_modules\",\n        \"**/*.spec.ts\"\n    ]\n}\n\n\n\n상세 설명\n\"compilerOptions\" 속성은 생략될 수 있으며 이 경우 컴파일러의 기본 값이 사용됩니다.지원되는 컴파일러 옵션의 전체 목록보기\n\"files\" 속성은 상대적이거나 절대적인 파일 경로 목록을 갖습니다.\"include\"와 \"exclude\"는 glob 파일 패턴의 목록과 같은 속성을 갖습니다.지원되는 glob 와일드카드는 다음과 같습니다:\n\n* 0개 이상의 문자와 매칭 (디렉토리 separator 제외)\n? 한 문자와 매칭 (디렉토리 separator 제외)\n**/ 반복적으로 모든 하위 디렉토리와 매칭\n\nglob 패턴의 구분에 * 또는 . *만 있는 경우, 지원하는 확장자 파일만 포함됩니다 (예: 기본적으로는 .ts, .tsx 및 .d.ts / allowJs true로 설정시 .js와 .jsx).\n\"files\"과 \"include\" 모두 지정되어 있지 않을 경우 컴파일러는 기본적으로 모든 TypeScript (.ts,.d.ts 그리고 .tsx) 파일을 포함하는 디렉토리와 하위 디렉토리에 포함시킵니다.\"exclude\" 속성을 사용하여 제외된 것은 제외합니다.allowJs가 true로 설정되면 JS 파일(.js와 .jsx)도 포함됩니다.\n\"files\"과 \"include\" 모두 지정되어 있는 경우 컴파일러는 그 두 속성에 포함된 파일의 결합(union)을 대신 포함합니다.\"outDir\" 컴파일러 옵션을 사용하여 지정된 디렉토리의 파일들은 \"exclude\" 속성이 지정되지 않은 한 제외됩니다.\n\"include\"을 사용하여 포함된 파일들은 \"exclude\" 속성을 사용해 필터링할 수 있습니다.그러나 \"files\" 속성을 명시적으로 사용하는 파일은 \"exclude\"에 관계없이 항상 포함됩니다.\"exclude\" 속성에 디렉토리가 지정되지 있지 않을 경우 node_modules, bower_components, jspm_packages 그리고 를 제외합니다.\n\"files\" 또는 \"include\" 속성을 통해 파일에 참조되는 모든 파일도 포함됩니다.  \n비슷하게, 파일 B.ts가 또 다른 파일 A.ts에 의해 참조되는 경우, B.ts는 참조 파일 A.ts가 \"exclude\" 리스트에서도 지정되지 않는 한 제외될 수 없습니다.\n컴파일러에는 실행할 수 있는 출력 파일이 포함되어 있지 않다는 점에 주의해야 합니다.즉 입력에 index.ts가 포함되면 index.d.ts와 index.js는 제외됩니다.일반적으로 파일이 확장자만 다르게 나란히 있는 것은 권장하지 않습니다.\ntsconfig.json 파일은 완전히 비어있을 수 있습니다.기본 컴파일러 옵션으로 기본적인(위에서 설명한대로) 포함된 모든 파일을 컴파일합니다.\n기본 컴파일러 옵션으로 기본적으로(위에서 설명한대로) 모든 파일을 컴파일하는 것이 tsconfig.json파일을 완전히 비워 두는 것을 허용하십시오.\n커맨드 라인에 지정된 컴파일러 옵션은 tsconfig.json 파일에 지정된 옵션을 오버라이드합니다.\n@types, typeRoots 및 types\n기본적으로 표시된 모든 \"@types\" 패키지가 컴파일에 포함됩니다.동봉된 모든 폴더의 node_modules/@types 패키지는 표시된 것으로 간주됩니다.구체적으로 ./node_modules/@types/,  ../node_modules/@types/, ../../node_modules/@types/ 등의 패키지를 의미합니다.\ntypeRoots를 지정하면 typeRoots 아래에 있는 패키지만 포함됩니다.\n예를 들어\n{\n   \"compilerOptions\": {\n       \"typeRoots\" : [\"./typings\"]\n   }\n}\n\n이 설정 파일에는 ./typings의 모든 패키지가 포함되며 ./node_modules/@types의 패키지는 포함되지 않습니다.\ntypes을 지정할 경우 나열된 패키지만 포함됩니다.\n예를 들어:\n{\n   \"compilerOptions\": {\n       \"types\" : [\"node\", \"lodash\", \"express\"]\n   }\n}\n\n이 tsconfig.json은 오직 ./node_modules/@types/node, ./node_modules/@types/lodash 및 ./node_modules/@types/express만 포함합니다.node_modules/@types/* 아래의 다른 패키지는 포함되지 않습니다.\ntypes 패키지는 index.d.ts 파일이 있는 폴더 또는 폴더에 types 필드를 가진 package.json가 있는 폴더입니다.\n\"types\": []를 지정하면 @types 패키지가 자동으로 포함되지 않습니다.\n전역 선언이 포함된 파일을 사용하는 경우에만 자동 포함이 중요하다는 점에 명심하세요 (모듈로 선언된 파일과 달리).\n예를 들어 import \"foo\" 문을 사용한다면 TypeScript는 여전히 node_modules & node_modules/@types 폴더를 보고 foo 패키지를 찾을 것입니다.\nextends를 이용한 설정 상속 (Configuration inheritance with extends)\ntsconfig.json 파일은 extends 속성을  사용해 다른 파일의 설정을 상속할 수 있습니다.\nextends는 tsconfig.json의 최상위 속성 (compilerOptions,files,include 및 exclude와 함께) 입니다.extends' 값은 상속받을 다른 설정 파일의 경로를 포함하는 문자열입니다.\n기본 파일의 설정이 먼저 로드된 다음 상속되는 설정 파일의 설정에 의해 재정의됩니다.순환성 장애와 맞닥뜨리면 오류를 보고합니다.상속 설정 파일에서 files, include 및 exclude는 기본 설정 파일을 덮어씁니다.\n설정 파일에 있는 모든 상대적 경로는 해당 경로가 원래 있던 설정 파일을 기준으로 해석됩니다.\n예를 들어:\nconfigs/base.json:\n{\n  \"compilerOptions\": {\n    \"noImplicitAny\": true,\n    \"strictNullChecks\": true\n  }\n}\n\ntsconfig.json:\n{\n  \"extends\": \"./configs/base\",\n  \"files\": [\n    \"main.ts\",\n    \"supplemental.ts\"\n  ]\n}\n\ntsconfig.nostrictnull.json:\n{\n  \"extends\": \"./tsconfig\",\n  \"compilerOptions\": {\n    \"strictNullChecks\": false\n  }\n}\n\ncompileOnSave\n최상위 속성 compileOnSave를 IDE에 설정하면 저장 시 지정된 tsconfig.json에 대한 모든 파일을 생성합니다.\n{\n   \"compileOnSave\": true,\n   \"compilerOptions\": {\n       \"noImplicitAny\" : true\n   }\n}\n\n이 기능은 현재 TypeScript 1.8.4 이상과 atom-typescript 플러그인이 있는 Visual Studio 2015에서 지원됩니다.\n스키마\n스키마는 http://json.schemastore.org/tsconfig에서 찾을 수 있습니다.\n"},"pages/Compiler Options.html":{"url":"pages/Compiler Options.html","title":"컴파일러 옵션","keywords":"","body":"컴파일러 옵션\n\n\n\n옵션\n타입\n기본값\n설명\n\n\n\n\n--allowJs\nboolean\nfalse\nJavaScript 파일 컴파일 허용합니다\n\n\n--allowSyntheticDefaultImports\nboolean\nmodule === \"system\"\ndefault export가 없는 모듈에서 default imports를 허용합니다. 코드 방출에는 영향을 주지 않으며 단지 타입 검사에 불과합니다.\n\n\n--allowUnreachableCode\nboolean\nfalse\n연결할 수 없는 코드에 대한 오류를 보고하지 않습니다.\n\n\n--allowUnusedLabels\nboolean\nfalse\n사용되지 않는 레이블에 대한 오류 보고하지 않습니다.\n\n\n--alwaysStrict\nboolean\nfalse\n각 소스 파일에 대해 strict 모드로 구문 파싱을 하고 \"use strict\"을 내보냅니다.\n\n\n--baseUrl\nstring\n\n비-상대적 모듈 이름을 해석하기 위한 기본 디렉토리. 자세한 내용은 모듈 해석 문서을 참조하세요.\n\n\n--charset\nstring\n\"utf8\"\n입력 파일의 문자열 집합입니다 (인코딩 관련).\n\n\n--checkJs\nboolean\nfalse\n.js 파일에 오류를 보고합니다. --allowJs와 함께 사용하세요.\n\n\n--declaration-d\nboolean\nfalse\n해당하는 .d.ts 파일을 생성합니다.\n\n\n--declarationDir\nstring\n\n생성된 선언 파일의 출력 디렉토리입니다.\n\n\n--diagnostics\nboolean\nfalse\n진단 정보를 보여줍니다.\n\n\n--disableSizeLimit\nboolean\nfalse\nJavaScript 프로젝트의 사이즈 제한을 중지합니다.\n\n\n--downlevelIteration\nboolean\nfalse\nES5 또는 ES3를 대상으로 할 때 for..of, spread 및 destructuring 반복 가능한 iterables 지원을 제공합니다.\n\n\n--emitBOM\nboolean\nfalse\n출력 파일의 시작 부분에 UTF-8 바이트 순서표(BOM)를 내보냅니다.\n\n\n--emitDecoratorMetadata[1]\nboolean\nfalse\n소스에 데코레이터 선언에 대한 설계 타입 메타 데이터를 내보냅니다. 자세한 내용은 #2577 이슈을 참조하세요.\n\n\n--experimentalDecorators[1]\nboolean\nfalse\nES 데코레이터에 대한 실험적인 지원을 사용하도록 활성화합니다.\n\n\n--forceConsistentCasingInFileNames\nboolean\nfalse\n동일한 파일에 대해 일관성이 없는 참조는 허용하지 않습니다.\n\n\n--help-h\n\n\n도움말을 출력합니다.\n\n\n--importHelpers\nboolean\nfalse\n방출된 헬퍼를 임포트합니다. tslib로부터 (예. __extends, __rest, 등..)\n\n\n--inlineSourceMap\nboolean\nfalse\n별도의 파일 대신 소스 맵으로 단일 파일을 내보냅니다.\n\n\n--inlineSources\nboolean\nfalse\n단일 파일 내에서 소스 맵과 함께 소스를 내보냅니다. --inlineSourceMap 또는 --sourceMap을 설정해야 합니다.\n\n\n--init\n\n\nTypeScript 프로젝트를 초기화하고 tsconfig.json 파일을 생성합니다.\n\n\n--isolatedModules\nboolean\nfalse\n각 파일을 별도의 모듈로 불리하여 변환합니다 (\"ts.transpileModule\"과 비슷합니다).\n\n\n--jsx\nstring\n\"Preserve\"\n.tsx 파일에서 JSX 지원: \"React\" 또는 \"Preserve\". JSX를 확인하세요.\n\n\n--jsxFactory\nstring\n\"React.createElement\"\n리액트 JSX 방출을 대상으로 할 때 사용할 JSX 팩토리 함수를 지정합니다. 예: React.createElement 또는 h.\n\n\n--lib\nstring[]\n\n컴파일에 포함될 라이브러리 파일 목록입니다.가능한 값은 다음과 같습니다:  ► ES5 ► ES6 ► ES2015 ► ES7 ► ES2016 ► ES2017 ► ESNext ► DOM ► DOM.Iterable ► WebWorker ► ScriptHost ► ES2015.Core ► ES2015.Collection ► ES2015.Generator ► ES2015.Iterable ► ES2015.Promise ► ES2015.Proxy ► ES2015.Reflect ► ES2015.Symbol ► ES2015.Symbol.WellKnown ► ES2016.Array.Include ► ES2017.object ► ES2017.SharedMemory ► ES2017.TypedArrays ► esnext.asynciterable ► esnext.promise  주의사항: --lib가 지정되지 않으면 라이브러리의 기본 리스트가 삽입됩니다. 주입되는 기본 라이브러리는 다음과 같습니다:   ► --target ES5: DOM,ES5,ScriptHost  ► --target ES6: DOM,ES6,DOM.Iterable,ScriptHost\n\n\n--listEmittedFiles\nboolean\nfalse\n컴파일의 일부로 생성된 파일의 이름을 출력합니다.\n\n\n--listFiles\nboolean\nfalse\n컴파일에 포함된 파일의 이름을 출력합니다.\n\n\n--locale\nstring\n(특정 플랫폼)\n오류 메시지를 표시하는 데 사용할 지역화, 예: en-us. 가능한 값은 다음과 같습니다:  ► English (US): en ► Czech: cs ► German: de ► Spanish: es ► French: fr ► Italian: it ► Japanese: ja ► Korean: ko ► Polish: pl ► Portuguese(Brazil): pt-BR ► Russian: ru ► Turkish: tr ► Simplified Chinese: zh-CN  ► Traditional Chinese: zh-TW\n\n\n--mapRoot\nstring\n\n디버거가 생성된 위치가 아닌 맵 파일의 위치를 지정합니다. .map 파일이 .js 파일과 다른 위치에 런타임 시 위치할 경우 이 옵션을 사용하세요. 지정된 위치는 sourceMap에 포함되어 맵 파일이 위치할 디버거를 지정합니다.\n\n\n--maxNodeModuleJsDepth\nnumber\n0\nnode_modules 및 로드 JavaScript 파일 아래에서 검색할 최대 의존성 깊이. --allowJs에만 적용됩니다.\n\n\n--module-m\nstring\ntarget === \"ES3\" or \"ES5\" ? \"CommonJS\" : \"ES6\"\n모듈 코드 생성 지정: \"None\", \"CommonJS\", \"AMD\", \"System\", \"UMD\", \"ES6\", \"ES2015\" 또는 \"ESNext\".► \"AMD\"와 \"System\"만 --outFile과 함께 사용할 수 있습니다.► \"ES6\"와 \"ES2015\" 값은 \"ES5\" 또는 이하를 대상으로 할 때 사용할 수 있습니다.\n\n\n--moduleResolution\nstring\nmodule === \"AMD\" or \"System\" or \"ES6\" ?  \"Classic\" : \"Node\"\n모듈 해석 방법 결정. Node.js/io.js 스타일 해석의 경우, \"Node\" 또는 \"Classic\" 중 하나입니다. 자세한 내용은 모듈 해석 문서를 참조하세요.\n\n\n--newLine\nstring\n(특정 플랫폼)\n파일을 내보낼 때 사용되는 지정된 라인 끝의 시퀀스 사용: \"crlf\" (윈도우) 또는 \"lf\" (유닉스).\"\n\n\n--noEmit\nboolean\nfalse\n출력을 내보내지 않습니다.\n\n\n--noEmitHelpers\nboolean\nfalse\n컴파일된 출력에서는 __extends와 같은 커스텀 헬퍼 함수를 생성하지 않습니다.\n\n\n--noEmitOnError\nboolean\nfalse\n오류가 보고된 경우 출력을 내보내지 않습니다.\n\n\n--noErrorTruncation\nboolean\nfalse\n오류 메세지를 줄이지 않습니다.\n\n\n--noFallthroughCasesInSwitch\nboolean\nfalse\n스위치 문에 fallthrough 케이스에 대한 오류를 보고합니다.\n\n\n--noImplicitAny\nboolean\nfalse\nany 타입으로 암시한 표현식과 선언에 오류를 발생시킵니다.\n\n\n--noImplicitReturns\nboolean\nfalse\n함수의 모든 코드 경로에 반환값이 없을 때 오류를 보고합니다.\n\n\n--noImplicitThis\nboolean\nfalse\nany 타입으로 암시한 this 표현식에 오류를 보고합니다.\n\n\n--noImplicitUseStrict\nboolean\nfalse\n모듈 출력에 \"use strict\" 지시자를 내보내지 않습니다.\n\n\n--noLib\nboolean\nfalse\n기본 라이브러리 파일(lib.d.ts)은 포함하지 않습니다.\n\n\n--noResolve\nboolean\nfalse\n컴파일된 파일 목록에 트리플-슬래시 참조 또는 모듈 임포트 대상을 추가하지 않습니다.\n\n\n--noStrictGenericChecks\nboolean\nfalse\n함수 타입에서 제네릭 시그니처의 엄격한 검사를 비활성화합니다.\n\n\n--noUnusedLocals\nboolean\nfalse\n사용하지 않는 지역 변수에 대한 오류를 보고합니다.\n\n\n--noUnusedParameters\nboolean\nfalse\n사용하지 않는 매개 변수에 대한 오류를 보고합니다.\n\n\n--out\nstring\n\nDEPRECATED 되었습니다. --outFile을 대신 사용합니다.\n\n\n--outDir\nstring\n\n출력 구조를 디렉토리로 리다이렉트합니다.\n\n\n--outFile\nstring\n\n출력을 단일 파일로 연결하여 방출합니다. 연결의 순서는 컴파일러에 전달된 파일 목록과 트리플-슬래시 참조 그리고 임포트와 함께 결정됩니다. 자세한 내용은 출력 파일 순서 문서를 참조하세요.\n\n\npaths[2]\nObject\n\nbaseUrl을 기준으로 관련된 위치에 모듈 이름의 경로 매핑 목록을 나열합니다. 자세한 내용은 모듈 해석 문서를 참조하세요.\n\n\n--preserveConstEnums\nboolean\nfalse\n생성된 코드에 const enum 선언을 지우지 않습니다. 자세한 내용은 const 열거형 문서를 참조하세요.\n\n\n--preserveSymlinks\nboolean\nfalse\nsymlinks를 실제 경로로 해석하지 않습니다. symlinked된 파일을 실제 파일처럼 다룹니다.\n\n\n--pretty[1]\nboolean\nfalse\n색상 및 컨텍스트를 사용하여 오류 및 메세지 스타일을 지정합니다.\n\n\n--project-p\nstring\n\n유효한 설정 파일이 지정된 프로젝트를 컴파일하세요.이 인수는 유효한 JSON 설정 파일의 파일 경로일 수도 있고 tsconfig.json 파일이 포함된 디렉토리의 경로일 수도 있습니다.자세한 내용은 tsconfig.json를 참조하세요.\n\n\n--reactNamespace\nstring\n\"React\"\nDEPRECATED 되었습니다. --jsxFactory를 대신 사용합니다.\"react\" JSX emit을 대상으로 할 때 createElement와 __spread에 호출된 객체를 지정합니다.\n\n\n--removeComments\nboolean\nfalse\n/*!로 시작하는 copy-right 헤더 주석을 제외한 모든 주석을 제거합니다.\n\n\n--rootDir\nstring\n(공통 루트 디렉토리는 input files 리스트에서 처리됩니다)\n입력 파일의 루트 디렉토리를 지정합니다. --outDir로 출력 디렉토리 구조를 제어하기 위해서만 사용합니다.\n\n\nrootDirs[2]\nstring[]\n\n런타임 시 결합된 컨텐츠가 프로젝트의 구조를 나타내는 루트 폴더 목록입니다. 자세한 내용은 모듈 해석 문서를 참조하세요.\n\n\n--skipDefaultLibCheck\nboolean\nfalse\nDEPRECATED 되었습니다. --skipLibCheck를 대신 사용합니다.기본 라이브러리 선언 파일의 타입 검사 건너뛰기[default library declaration files].\n\n\n--skipLibCheck\nboolean\nfalse\n모든 선언 파일(*.d.ts)의 타입 검사를 건너뜁니다.\n\n\n--sourceMap\nboolean\nfalse\n해당하는 .map 파일을 생성합니다.\n\n\n--sourceRoot\nstring\n\n디버거가 소스 위치 대신 TypeScript 파일을 찾아야 하는 위치를 지정합니다. 설계 시점에 소스가 아닌 런타임에 소스가 있는 경우 이 옵션을 사용하세요. 지정한 위치는 소스 파일이 위치할 디버깅 위치를 지정하기 위해 소스 맵에 포함됩니다.\n\n\n--strict\nboolean\nfalse\n모든 엄격한 타입 검사 옵션을 활성화합니다. --strict를 활성화하면 --noImplicitAny, --noImplicitThis, --alwaysStrict, --strictNullChecks 및 --strictFunctionTypes이 가능합니다.\n\n\n--strictFunctionTypes\nboolean\nfalse\n함수 타입에 대한 bivariant 매개변수를 비활성화합니다.\n\n\n--strictNullChecks\nboolean\nfalse\nstrict null checking 모드에서는 null과 undefined 값이 모든 타입의 도메인에 있지 않고 그 자체와 any만 할당할 수  있습니다(한 가지 예외사항은 undefined 또한 void에 할당 가능하다는 것입니다).\n\n\n--stripInternal[1]\nboolean\nfalse\n/** @internal */ JSDoc 주석을 가진 코드에 대한 선언을 방출하지 않습니다.\n\n\n--suppressExcessPropertyErrors\nboolean\nfalse\n객체 리터럴에 대한 프로퍼티 초과 검사를 억제합니다.\n\n\n--suppressImplicitAnyIndexErrors\nboolean\nfalse\n인덱스 시그니처가 없는 객체를 인덱싱하는 경우 --noImplicitAny 억제합니다. 오류를 시그니처 자세한 내용은 #1232 이슈를 참조하세요.\n\n\n--target-t\nstring\n\"ES3\"\nECMAScript 대상 버전 지정: \"ES3\" (기본값), \"ES5\", \"ES6\"/\"ES2015\", \"ES2016\", \"ES2017\" 또는 \"ESNext\".  주의사항: \"ESNext\"는 최신 ES 제안 기능을 대상으로 합니다.\n\n\n--traceResolution\nboolean\nfalse\n모듈 해석 로그 메세지를 보고합니다.\n\n\n--types\nstring[]\n\n타입 정의가 포함될 이름의 목록. 자세한 내용은 @types, --typeRoots 및 --types를 참조하세요.\n\n\n--typeRoots\nstring[]\n\n타입 정의가 포함될 폴더의 목록. 자세한 내용은 @types, --typeRoots 및 --types를 참조하세요.\n\n\n--version-v\n\n\n컴파일러의 버전을 출력합니다.\n\n\n--watch-w\n\n\n컴파일러를 와치 모드로 실행합니다. 입력 파일을 와치하여 변경 시 다시 컴파일합니다.\n\n\n\n\n[1] 이 옵션은 실험단계입니다.\n[2] 이 옵션은 tsconfig.json에서만 허용되며 커맨드 라인에서는 허용되지 않습니다.\n\n관련사항\n\ntsconfig.json 파일에서 컴파일러 옵션 설정하기\nMSBuild projects 프로젝트에서 컴파일러 옵션 설정하기\n\n"},"pages/Project References.html":{"url":"pages/Project References.html","title":"프로젝트 레퍼런스","keywords":"","body":"Project references are a new feature in TypeScript 3.0 that allow you to structure your TypeScript programs into smaller pieces.\nBy doing this, you can greatly improve build times, enforce logical separation between components, and organize your code in new and better ways.\nWe're also introducing a new mode for tsc, the --build flag, that works hand in hand with project references to enable faster TypeScript builds.\nAn Example Project\nLet's look at a fairly normal program and see how project references can help us better organize it.\nImagine you have a project with two modules, converter and units, and a corresponding test file for each:\n/src/converter.ts\n/src/units.ts\n/test/converter-tests.ts\n/test/units-tests.ts\n/tsconfig.json\n\nThe test files import the implementation files and do some testing:\n// converter-tests.ts\nimport * as converter from \"../converter\";\n\nassert.areEqual(converter.celsiusToFahrenheit(0), 32);\n\nPreviously, this structure was rather awkward to work with if you used a single tsconfig file:\n\nIt was possible for the implementation files to import the test files\nIt wasn't possible to build test and src at the same time without having src appear in the output folder name, which you probably don't want\nChanging just the internals in the implementation files required typechecking the tests again, even though this wouldn't ever cause new errors\nChanging just the tests required typechecking the implementation again, even if nothing changed\n\nYou could use multiple tsconfig files to solve some of those problems, but new ones would appear:\n\nThere's no built-in up-to-date checking, so you end up always running tsc twice\nInvoking tsc twice incurs more startup time overhead\ntsc -w can't run on multiple config files at once\n\nProject references can solve all of these problems and more.\nWhat is a Project Reference?\ntsconfig.json files have a new top-level property, references. It's an array of objects that specifies projects to reference:\n{\n    \"compilerOptions\": {\n        // The usual\n    },\n    \"references\": [\n        { \"path\": \"../src\" }\n    ]\n}\n\nThe path property of each reference can point to a directory containing a tsconfig.json file, or to the config file itself (which may have any name).\nWhen you reference a project, new things happen:\n\nImporting modules from a referenced project will instead load its output declaration file (.d.ts)\nIf the referenced project produces an outFile, the output file .d.ts file's declarations will be visible in this project\nBuild mode (see below) will automatically build the referenced project if needed\n\nBy separating into multiple projects, you can greatly improve the speed of typechecking and compiling, reduce memory usage when using an editor, and improve enforcement of the logical groupings of your program.\ncomposite\nReferenced projects must have the new composite setting enabled.\nThis setting is needed to ensure TypeScript can quickly determine where to find the outputs of the referenced project.\nEnabling the composite flag changes a few things:\n\nThe rootDir setting, if not explicitly set, defaults to the directory containing the tsconfig file\nAll implementation files must be matched by an include pattern or listed in the files array. If this constraint is violated, tsc will inform you which files weren't specified\ndeclaration must be turned on\n\ndeclarationMaps\nWe've also added support for declaration source maps.\nIf you enable --declarationMap, you'll be able to use editor features like \"Go to Definition\" and Rename to transparently navigate and edit code across project boundaries in supported editors.\nprepend with outFile\nYou can also enable prepending the output of a dependency using the prepend option in a reference:\n   \"references\": [\n       { \"path\": \"../utils\", \"prepend\": true }\n   ]\n\nPrepending a project will include the project's output above the output of the current project.\nThis works for both .js files and .d.ts files, and source map files will also be emitted correctly.\ntsc will only ever use existing files on disk to do this process, so it's possible to create a project where a correct output file can't be generated because some project's output would be present more than once in the resulting file.\nFor example:\n   A\n  ^ ^\n /   \\\nB     C\n ^   ^\n  \\ /\n   D\n\nIt's important in this situation to not prepend at each reference, because you'll end up with two copies of A in the output of D - this can lead to unexpected results.\nCaveats for Project References\nProject references have a few trade-offs you should be aware of.\nBecause dependent projects make use of .d.ts files that are built from their dependencies, you'll either have to check in certain build outputs or build a project after cloning it before you can navigate the project in an editor without seeing spurious errors.\nWe're working on a behind-the-scenes .d.ts generation process that should be able to mitigate this, but for now we recommend informing developers that they should build after cloning.\nAdditionally, to preserve compatibility with existing build workflows, tsc will not automatically build dependencies unless invoked with the --build switch.\nLet's learn more about --build.\nBuild Mode for TypeScript\nA long-awaited feature is smart incremental builds for TypeScript projects.\nIn 3.0 you can use the --build flag with tsc.\nThis is effectively a new entry point for tsc that behaves more like a build orchestrator than a simple compiler.\nRunning tsc --build (tsc -b for short) will do the following:\n\nFind all referenced projects\nDetect if they are up-to-date\nBuild out-of-date projects in the correct order\n\nYou can provide tsc -b with multiple config file paths (e.g. tsc -b src test).\nJust like tsc -p, specifying the config file name itself is unnecessary if it's named tsconfig.json.\ntsc -b Commandline\nYou can specify any number of config files:\n > tsc -b                            # Use the tsconfig.json in the current directory\n > tsc -b src                        # Use src/tsconfig.json\n > tsc -b foo/prd.tsconfig.json bar  # Use foo/prd.tsconfig.json and bar/tsconfig.json\n\nDon't worry about ordering the files you pass on the commandline - tsc will re-order them if needed so that dependencies are always built first.\nThere are also some flags specific to tsc -b:\n\n--verbose: Prints out verbose logging to explain what's going on (may be combined with any other flag)\n--dry: Shows what would be done but doesn't actually build anything\n--clean: Deletes the outputs of the specified projects (may be combined with --dry)\n--force: Act as if all projects are out of date\n--watch: Watch mode (may not be combined with any flag except --verbose)\n\nCaveats\nNormally, tsc will produce outputs (.js and .d.ts) in the presence of syntax or type errors, unless noEmitOnError is on.\nDoing this in an incremental build system would be very bad - if one of your out-of-date dependencies had a new error, you'd only see it once because a subsequent build would skip building the now up-to-date project.\nFor this reason, tsc -b effectively acts as if noEmitOnError is enabled for all projects.\nIf you check in any build outputs (.js, .d.ts, .d.ts.map, etc.), you may need to run a --force build after certain source control operations depending on whether your source control tool preserves timestamps between the local copy and the remote copy.\nMSBuild\nIf you have an msbuild project, you can enable build mode by adding\n    true\n\nto your proj file. This will enable automatic incremental build as well as cleaning.\nNote that as with tsconfig.json / -p, existing TypeScript project properties will not be respected - all settings should be managed using your tsconfig file.\nSome teams have set up msbuild-based workflows wherein tsconfig files have the same implicit graph ordering as the managed projects they are paired with.\nIf your solution is like this, you can continue to use msbuild with tsc -p along with project references; these are fully interoperable.\nGuidance\nOverall Structure\nWith more tsconfig.json files, you'll usually want to use Configuration file inheritance to centralize your common compiler options.\nThis way you can change a setting in one file rather than having to edit multiple files.\nAnother good practice is to have a \"solution\" tsconfig.json file that simply has references to all of your leaf-node projects and sets files to an empty array (otherwise the solution file will cause double compilation of files). Note that starting with 3.0, it is no longer an error to have an empty files array if you have at least one reference in a tsconfig.json file.\nThis presents a simple entry point; e.g. in the TypeScript repo we simply run tsc -b src to build all endpoints because we list all the subprojects in src/tsconfig.json\nYou can see these patterns in the TypeScript repo - see src/tsconfig_base.json, src/tsconfig.json, and src/tsc/tsconfig.json as key examples.\nStructuring for relative modules\nIn general, not much is needed to transition a repo using relative modules.\nSimply place a tsconfig.json file in each subdirectory of a given parent folder, and add references to these config files to match the intended layering of the program.\nYou will need to either set the outDir to an explicit subfolder of the output folder, or set the rootDir to the common root of all project folders.\nStructuring for outFiles\nLayout for compilations using outFile is more flexible because relative paths don't matter as much.\nOne thing to keep in mind is that you'll generally want to not use prepend until the \"last\" project - this will improve build times and reduce the amount of I/O needed in any given build.\nThe TypeScript repo itself is a good reference here - we have some \"library\" projects and some \"endpoint\" projects; \"endpoint\" projects are kept as small as possible and pull in only the libraries they need.\n\n"},"pages/Compiler Options in MSBuild.html":{"url":"pages/Compiler Options in MSBuild.html","title":"MSBuild에서의 컴파일러 옵션","keywords":"","body":"개요\n컴파일러 옵션은 MSBuild 프로젝트 내의 MSBuild 속성을 사용하여 지정할 수 있습니다.\n예제\n  \n    false\n    true\n  \n  \n    true\n    false\n  \n  \n\n맵핑\n\n\n\n컴파일러 옵션\nMSBuild 속성 이름\n허용된 값\n\n\n\n\n--allowJs\nMSBuild에서 지원되지 않습니다\n\n\n\n--allowSyntheticDefaultImports\nTypeScriptAllowSyntheticDefaultImports\nboolean\n\n\n--allowUnreachableCode\nTypeScriptAllowUnreachableCode\nboolean\n\n\n--allowUnusedLabels\nTypeScriptAllowUnusedLabels\nboolean\n\n\n--alwaysStrict\nTypeScriptAlwaysStrict\nboolean\n\n\n--baseUrl\nTypeScriptBaseUrl\n파일 경로\n\n\n--charset\nTypeScriptCharset\n\n\n\n--declaration\nTypeScriptGeneratesDeclarations\nboolean\n\n\n--declarationDir\nTypeScriptDeclarationDir\n파일 경로\n\n\n--diagnostics\nMSBuild에서 지원되지 않습니다\n\n\n\n--disableSizeLimit\nMSBuild에서 지원되지 않습니다\n\n\n\n--emitBOM\nTypeScriptEmitBOM\nboolean\n\n\n--emitDecoratorMetadata\nTypeScriptEmitDecoratorMetadata\nboolean\n\n\n--experimentalAsyncFunctions\nTypeScriptExperimentalAsyncFunctions\nboolean\n\n\n--experimentalDecorators\nTypeScriptExperimentalDecorators\nboolean\n\n\n--forceConsistentCasingInFileNames\nTypeScriptForceConsistentCasingInFileNames\nboolean\n\n\n--help\nMSBuild에서 지원되지 않습니다\n\n\n\n--importHelpers\nTypeScriptImportHelpers\nboolean\n\n\n--inlineSourceMap\nTypeScriptInlineSourceMap\nboolean\n\n\n--inlineSources\nTypeScriptInlineSources\nboolean\n\n\n--init\nMSBuild에서 지원되지 않습니다\n\n\n\n--isolatedModules\nTypeScriptIsolatedModules\nboolean\n\n\n--jsx\nTypeScriptJSXEmit\nReact 또는 Preserve\n\n\n--jsxFactory\nTypeScriptJSXFactory\n제한된 이름\n\n\n--lib\nTypeScriptLib\n쉼표로 구분된 문자열 목록\n\n\n--listEmittedFiles\nMSBuild에서 지원되지 않습니다\n\n\n\n--listFiles\nMSBuild에서 지원되지 않습니다\n\n\n\n--locale\n자동\n자동으로 PreferredUILang 값 설정\n\n\n--mapRoot\nTypeScriptMapRoot\n파일 경로\n\n\n--maxNodeModuleJsDepth\nMSBuild에서 지원되지 않습니다\n\n\n\n--module\nTypeScriptModuleKind\nAMD, CommonJs, UMD, System or ES6\n\n\n--moduleResolution\nTypeScriptModuleResolution\nClassic 또는 Node\n\n\n--newLine\nTypeScriptNewLine\nCRLF 또는 LF\n\n\n--noEmit\nMSBuild에서 지원되지 않습니다\n\n\n\n--noEmitHelpers\nTypeScriptNoEmitHelpers\nboolean\n\n\n--noEmitOnError\nTypeScriptNoEmitOnError\nboolean\n\n\n--noFallthroughCasesInSwitch\nTypeScriptNoFallthroughCasesInSwitch\nboolean\n\n\n--noImplicitAny\nTypeScriptNoImplicitAny\nboolean\n\n\n--noImplicitReturns\nTypeScriptNoImplicitReturns\nboolean\n\n\n--noImplicitThis\nTypeScriptNoImplicitThis\nboolean\n\n\n--noImplicitUseStrict\nTypeScriptNoImplicitUseStrict\nboolean\n\n\n--noStrictGenericChecks\nTypeScriptNoStrictGenericChecks\nboolean\n\n\n--noUnusedLocals\nTypeScriptNoUnusedLocals\nboolean\n\n\n--noUnusedParameters\nTypeScriptNoUnusedParameters\nboolean\n\n\n--noLib\nTypeScriptNoLib\nboolean\n\n\n--noResolve\nTypeScriptNoResolve\nboolean\n\n\n--out\nTypeScriptOutFile\n파일 경로\n\n\n--outDir\nTypeScriptOutDir\n파일 경로\n\n\n--outFile\nTypeScriptOutFile\n파일 경로\n\n\n--paths\nMSBuild에서 지원되지 않습니다\n\n\n\n--preserveConstEnums\nTypeScriptPreserveConstEnums\nboolean\n\n\n--preserveSymlinks\nTypeScriptPreserveSymlinks\nboolean\n\n\n--listEmittedFiles\nMSBuild에서 지원되지 않습니다\n\n\n\n--pretty\nMSBuild에서 지원되지 않습니다\n\n\n\n--reactNamespace\nTypeScriptReactNamespace\nstring\n\n\n--removeComments\nTypeScriptRemoveComments\nboolean\n\n\n--rootDir\nTypeScriptRootDir\n파일 경로\n\n\n--rootDirs\nMSBuild에서 지원되지 않습니다\n\n\n\n--skipLibCheck\nTypeScriptSkipLibCheck\nboolean\n\n\n--skipDefaultLibCheck\nTypeScriptSkipDefaultLibCheck\nboolean\n\n\n--sourceMap\nTypeScriptSourceMap\n파일 경로\n\n\n--sourceRoot\nTypeScriptSourceRoot\n파일 경로\n\n\n--strict\nTypeScriptStrict\nboolean\n\n\n--strictFunctionTypes\nTypeScriptStrictFunctionTypes\nboolean\n\n\n--strictNullChecks\nTypeScriptStrictNullChecks\nboolean\n\n\n--stripInternal\nTypeScriptStripInternal\nboolean\n\n\n--suppressExcessPropertyErrors\nTypeScriptSuppressExcessPropertyErrors\nboolean\n\n\n--suppressImplicitAnyIndexErrors\nTypeScriptSuppressImplicitAnyIndexErrors\nboolean\n\n\n--target\nTypeScriptTarget\nES3, ES5, 또는 ES6\n\n\n--traceResolution\nMSBuild에서 지원되지 않습니다\n\n\n\n--types\nMSBuild에서 지원되지 않습니다\n\n\n\n--typeRoots\nMSBuild에서 지원되지 않습니다\n\n\n\n--watch\nMSBuild에서 지원되지 않습니다\n\n\n\nMSBuild 전용 옵션\nTypeScriptAdditionalFlags\n모든 컴파일러 옵션\n\n\n\n여러분의 Visual Studio 버전에서 지원되는 기능은 무엇일까요?\nC:\\Program Files (x86)\\MSBuild\\Microsoft\\VisualStudio\\v$(VisualStudioVersion)\\TypeScript\\Microsoft.TypeScript.targets 파일을 확인하세요.MSBuild XML 태그와 tsc 컴파일러 옵션 사이의 신뢰할 수 있는 맵핑이 여기에 있습니다.\nToolsVersion\n프로젝트 파일의 1.7 속성 값은 빌드하는 데 사용할 컴파일러 버전을 식별합니다 (이 예제에서는 1.7).이렇게 하면 프로젝트가 다른 컴퓨터에 있는 동일한 버전의 컴파일러에 대한 빌드를 허용합니다.\n만약 TypeScriptToolsVersion이 지정되지 않으면 설치된 최신 컴파일러 버전을 사용하여 빌드합니다.\n최신 버전의 TS를 사용하는 사용자에게는 첫 로드 시 프로젝트를 업그레이드하라는 메시지가 표시됩니다\nTypeScriptCompileBlocked\n다른 빌드 도구를 사용하여 프로젝트 (예: 걸프, 그런트 등) 그리고 개발을 위한 VS와 디버깅 환경을 사용하는 경우 프로젝트에서 true를 설정하세요.\n이렇게 하면 모든 편집 지원이 제공되지만 F5키를 눌러도 빌드가 지원되지 않습니다.\n"},"pages/Integrating with Build Tools.html":{"url":"pages/Integrating with Build Tools.html","title":"빌드 도구와 통합","keywords":"","body":"빌드 도구들\n\nBrowserify\nDuo\nGrunt\nGulp\nJspm\nWebpack\nMSBuild\nNuGet\n\nBrowserify\n설치\nnpm install tsify\n\n커맨드 라인 인터페이스 사용\nbrowserify main.ts -p [ tsify --noImplicitAny ] > bundle.js\n\nAPI 사용\nvar browserify = require(\"browserify\");\nvar tsify = require(\"tsify\");\n\nbrowserify()\n    .add(\"main.ts\")\n    .plugin(\"tsify\", { noImplicitAny: true })\n    .bundle()\n    .pipe(process.stdout);\n\n자세한 내용: smrq/tsify\nDuo\n설치\nnpm install duo-typescript\n\n커맨드 라인 인터페이스 사용\nduo --use duo-typescript entry.ts\n\nAPI 사용\nvar Duo = require(\"duo\");\nvar fs = require(\"fs\")\nvar path = require(\"path\")\nvar typescript = require(\"duo-typescript\");\n\nvar out = path.join(__dirname, \"output.js\")\n\nDuo(__dirname)\n    .entry(\"entry.ts\")\n    .use(typescript())\n    .run(function (err, results) {\n        if (err) throw err;\n        // 컴파일된 결과를 출력 파일에 작성합니다.\n        fs.writeFileSync(out, results.code);\n    });\n\n자세한 내용: frankwallis/duo-typescript\nGrunt\n설치\nnpm install grunt-ts\n\n기본 Gruntfile.js\nmodule.exports = function(grunt) {\n    grunt.initConfig({\n        ts: {\n            default : {\n                src: [\"**/*.ts\", \"!node_modules/**/*.ts\"]\n            }\n        }\n    });\n    grunt.loadNpmTasks(\"grunt-ts\");\n    grunt.registerTask(\"default\", [\"ts\"]);\n};\n\n자세한 내용: TypeStrong/grunt-ts\nGulp\n설치\nnpm install gulp-typescript\n\nBasic gulpfile.js\nvar gulp = require(\"gulp\");\nvar ts = require(\"gulp-typescript\");\n\ngulp.task(\"default\", function () {\n    var tsResult = gulp.src(\"src/*.ts\")\n        .pipe(ts({\n              noImplicitAny: true,\n              out: \"output.js\"\n        }));\n    return tsResult.js.pipe(gulp.dest(\"built/local\"));\n});\n\n자세한 내용: ivogabe/gulp-typescript\nJspm\n설치\nnpm install -g jspm@beta\n\n주의사항: 현재 jspm의 TypeScript 지원은 0.16beta 입니다.\n자세한 내용: TypeScriptSamples/jspm\nWebpack\n설치\nnpm install ts-loader --save-dev\n\n기본 webpack.config.js\nmodule.exports = {\n    entry: \"./src/index.tsx\",\n    output: {\n        filename: \"bundle.js\"\n    },\n    resolve: {\n        // '.ts'와 '.tsx'를 해석 가능한 확장자로 추가합니다.\n        extensions: [\"\", \".webpack.js\", \".web.js\", \".ts\", \".tsx\", \".js\"]\n    },\n    module: {\n        loaders: [\n            // '.ts' 또는 '.tsx' 확장자를 가진 모든 파일은 'ts-loader'에 의해 처리됩니다.\n            { test: /\\.tsx?$/, loader: \"ts-loader\" }\n        ]\n    }\n}\n\nts-loader에 대한 자세한 내용은 여기를 참조하세요.\n대안:\n\nawesome-typescript-loader\n\nMSBuild\n프로젝트 파일을 업데이트하여 로컬에 설치된 Microsoft.TypeScript.Default.props (맨 위)와 Microsoft.TypeScript.targets (맨 아래) 파일을 포함하도록 하세요:\n\n\n  \n  \n\n  \n  \n    false\n    true\n  \n  \n    true\n    false\n  \n\n  \n  \n\n\nMSBuild 컴파일러 옵션 정의에 대한 자세한 내용: MSBuild 프로젝트의 컴파일러 옵션 설정\nNuGet\n\n우-클릭 -> Manage NuGet Packages\nMicrosoft.TypeScript.MSBuild를 검색하세요\nInstall 클릭\n설치가 완료되면 다시 빌드 하세요!\n\n자세한 내용은 패키지 매니저 다이얼로그와 NuGet과 nightly builds 사용\n"},"pages/Nightly Builds.html":{"url":"pages/Nightly Builds.html","title":"Nightly 빌드","keywords":"","body":"TypeScript의 master 브랜치의 nightly 빌드는 PST midnight까지 NPM과 NuGet에 배포됩니다.다음과 같이 도구를 사용하여 가져올 수 있습니다.\nnpm 사용\nnpm install -g typescript@next\n\nMSBuild에 NuGet 사용\n\n주의사항: NuGet 패키지를 사용하도록 프로젝트를 구성해야 합니다. 자세한 내용은 NuGet를 사용하도록 MSBuild 프로젝트 구성을 참조하십시오.\n\nnightlies는 www.myget.org에서 이용 가능합니다.\nThere are two packages:\n\nMicrosoft.TypeScript.Compiler: 도구만 (tsc.exe, lib.d.ts, 등.) .\nMicrosoft.TypeScript.MSBuild: 위와 같은 도구뿐만 아니라 MSBuild 작업 및 대상 (Microsoft.TypeScript.targets, Microsoft.TypeScript.Default.props, 등.)\n\nnightly 빌드를 사용하도록 IDE 업데이트\nnightly drop을 사용하도록 IDE를 업데이트할 수도 있습니다.먼저 npm을 통해 패키지를 설치해야 합니다.npm 패키지를 전역으로 설치하거나 로컬 node_modules 폴더에 설치할 수 있습니다.\n이 섹션의 나머지 부분에서는 typescript@next가 이미 설치되어 있다고 가정합니다.\nVisual Studio Code\n.vscode/settings.json 파일을 다음과 같이 업데이트하세요:\n\"typescript.tsdk\": \"/node_modules/typescript/lib\"\n\n자세한 내용은 VSCode 문서를 참조하세요.\nSublime Text\nSettings - User 파일을 다음과 같이 업데이트하세요:\n\"typescript_tsdk\": \"/node_modules/typescript/lib\"\n\n자세한 내용은 Sublime Text를 위한 TypeScript 플러그인 설치 문서를 참조하세요.\nVisual Studio 2013 및 2015\n\n주의사항: 대부분의 변경 사항에는 새로운 버전의 VS TypeScript 플러그인을 설치할 필요는 없습니다.\n\n현재 nightly build에는 전체 플러그인 설정이 포함되어 있지 않지만 nightly 기반으로 설치 프로그램을 배포하기 위해 노력하고 있습니다.\n\nVSDevMode.ps1 스크립트 다운로드.\n\n또한 커스텀 언어 서비스 파일 사용에 대한 위키 페이지를 참조하세요.\n\n\nPowerShell 커맨드 라인 창에서 다음을 실행합니다:\nVS 2015:\nVSDevMode.ps1 14 -tsScript /node_modules/typescript/lib\n\nVS 2013:\nVSDevMode.ps1 12 -tsScript /node_modules/typescript/lib\n\n\n\nIntelliJ IDEA (Mac)\nPreferences > Languages & Frameworks > TypeScript를 선택합니다:\n\nTypeScript 버전: npm과 함께 설치한 경우: /usr/local/lib/node_modules/typescript/lib\n\n"},"pages/release notes/TypeScript 3.8.html":{"url":"pages/release notes/TypeScript 3.8.html","title":"TypeScript 3.8","keywords":"","body":"\n타입-전용 Imports 와 Exports\nECMAScript 비공개 필드\nexport * as ns 구문\n최상위-레벨 await\nJSDoc 프로퍼티 지정자\n리눅스에서 더 나은 디렉터리 감시와 watchOptions\n\"빠르고 느슨한\" 증분 검사\n\n 타입-전용 Imports 와 Exports (Type-Only Imports and Exports)\n이 기능은 대부분의 사용자에겐 생각할 필요가 없을 수도 있지만; --isolatedModules, TypeScript의 transpileModule API, 또는 Babel에서 문제가 발생하면 이 기능과 관련이 있을 수 있습니다.\nTypeScript 3.8은 타입-전용 imports, exports를 위한 새로운 구문이 추가되었습니다.\nimport type { SomeThing } from \"./some-module.js\";\n\nexport type { SomeThing };\n\nimport type은 타입 표기와 선언에 사용될 선언만 import 합니다.\n이는 항상 완전히 제거되므로, 런타임에 남아있는 것은 없습니다.\n마찬가지로, export type은 타입 문맥에 사용할 export만 제공하며, 이 또한 TypeScript의 출력물에서 제거됩니다.\n클래스는 런타임에 값을 가지고 있고 디자인-타임에 타입이 있으며 사용은 상황에-따라 다르다는 것을 유의해야 합니다.\n클래스를 import 하기 위해 import type을 사용하면, 확장 같은 것은 할 수 없습니다.\nimport type { Component } from \"react\";\n\ninterface ButtonProps {\n    // ...\n}\n\nclass Button extends Component {\n    //               ~~~~~~~~~\n    // error! 'Component' only refers to a type, but is being used as a value here.\n\n    // ...\n}\n\n이전에 Flow를 사용해본 적이 있다면, 이 구문은 상당히 유사합니다.\n한 가지 차이점은 코드가 모호해 보이지 않도록 몇 가지 제한을 두었다는 것입니다.\n// 'Foo'만 타입인가? 혹은 모든 import 선언이 타입인가?\n// 이는 명확하지 않기 때문에 오류로 처리합니다.\n\nimport type Foo, { Bar, Baz } from \"some-module\";\n//     ~~~~~~~~~~~~~~~~~~~~~~\n// error! A type-only import can specify a default import or named bindings, but not both.\n\nimport type과 함께, TypeScript 3.8은 런타임 시 사용되지 않는 import에서 발생하는 작업을 제어하기 위해 새로운 컴파일러 플래그를 추가합니다: importsNotUsedAsValues.\n이 플래그는 3 가지 다른 값을 가집니다:\n\nremove: 이는 imports를 제거하는 현재 동작이며, 계속 기본값으로 작동할 것이며, 기존 동작을 바꾸는 변화가 아닙니다.\npreserve: 이는 사용되지 않는 값들을 모두 보존합니다. 이로 인해 imports/side-effects가 보존될 수 있습니다.\nerror: 이는 모든 (preserve option 처럼) 모든 imports를 보존하지만, import 값이 타입으로만 사용될 경우 오류를 발생시킵니다. 이는 실수로 값을 import하지 않지만 사이드 이팩트 import를 명시적으로 만들고 싶을 때 유용합니다.\n\n이 기능에 대한 더 자세한 정보는, import type선언이 사용될수 있는 범위를 확대하는 pull request, 와 관련된 변경 사항에서 찾을 수 있습니다.\n ECMAScript 비공개 필드 (ECMAScript Private Fields)\nTypeScript 3.8 은 ECMAScript의 stage-3 클래스 필드 제안의 비공개 필드를 지원합니다.\nclass Person {\n    #name: string\n\n    constructor(name: string) {\n        this.#name = name;\n    }\n\n    greet() {\n        console.log(`Hello, my name is ${this.#name}!`);\n    }\n}\n\nlet jeremy = new Person(\"Jeremy Bearimy\");\n\njeremy.#name\n//     ~~~~~\n// 프로퍼티 '#name'은 'Person' 클래스 외부에서 접근할 수 없습니다.\n// 이는 비공개 식별자를 가지기 때문입니다.\n\n일반적인 프로퍼티들(private 지정자로 선언한 것도)과 달리, 비공개 필드는 몇 가지 명심해야 할 규칙이 있습니다.\n그중 몇몇은:\n\n비공개 필드는 # 문자로 시작합니다. 때때로 이를 비공개 이름(private names) 이라고 부릅니다.\n모든 비공개 필드 이름은 이를 포함한 클래스 범위에서 유일합니다.\npublic 또는 private 같은 TypeScript 접근 지정자는 비공개 필드로 사용될 수 없습니다.  \nJS 사용자로부터도 비공개 필드는 이를 포함한 클래스 밖에서 접근하거나 탐지할 수 없습니다! 때때로 이를 강한 비공개(hard privacy) 라고 부릅니다.\n\n\"강한\" 비공개와 별도로, 비공개 필드의 또 다른 장점은 유일하다는 것입니다.\n예를 들어, 일반적인 프로퍼티 선언은 하위클래스에서 덮어쓰기 쉽습니다.\nclass C {\n    foo = 10;\n\n    cHelper() {\n        return this.foo;\n    }\n}\n\nclass D extends C {\n    foo = 20;\n\n    dHelper() {\n        return this.foo;\n    }\n}\n\nlet instance = new D();\n// 'this.foo' 는 각 인스턴스마다 같은 프로퍼티를 참조합니다.\nconsole.log(instance.cHelper()); // '20' 출력\nconsole.log(instance.dHelper()); // '20' 출력\n\n비공개 필드에서는, 포함하고 있는 클래스에서 각각의 필드 이름이 유일하기 때문에 이에 대해 걱정하지 않아도 됩니다.\nclass C {\n    #foo = 10;\n\n    cHelper() {\n        return this.#foo;\n    }\n}\n\nclass D extends C {\n    #foo = 20;\n\n    dHelper() {\n        return this.#foo;\n    }\n}\n\nlet instance = new D();\n// 'this.#foo' 는 각 클래스안의 다른 필드를 참조합니다.\nconsole.log(instance.cHelper()); // '10' 출력\nconsole.log(instance.dHelper()); // '20' 출력\n\n알아 두면 좋은 또 다른 점은 다른 타입으로 비공개 필드에 접근하면 TypeError 를 발생한다는 것입니다.\nclass Square {\n    #sideLength: number;\n\n    constructor(sideLength: number) {\n        this.#sideLength = sideLength;\n    }\n\n    equals(other: any) {\n        return this.#sideLength === other.#sideLength;\n    }\n}\n\nconst a = new Square(100);\nconst b = { sideLength: 100 };\n\n// Boom!\n// TypeError: attempted to get private field on non-instance\n// 이는 `b` 가 `Square`의 인스턴스가 아니기 때문에 실패 합니다.\nconsole.log(a.equals(b));\n\n마자막으로, 모든 일반 .js 파일 사용자들의 경우, 비공개 필드는 항상 할당되기 전에 선언되어야 합니다.\nclass C {\n    // '#foo' 선언이 없습니다.\n    // :(\n\n    constructor(foo: number) {\n        // SyntaxError!\n        // '#foo'는 쓰여지기 전에 선언되어야 합니다.\n        this.#foo = foo;\n    }\n}\n\nJavaScript는 항상 사용자들에게 선언되지 않은 프로퍼티에 접근을 허용했지만, TypeScript는 항상 클래스 프로퍼티 선언을 요구했습니다.\n비공개 필드는, .js 또는 .ts 파일에서 동작하는지 상관없이 항상 선언이 필요합니다.\nclass C {\n    /** @type {number} */\n    #foo;\n\n    constructor(foo: number) {\n        // 동작합니다.\n        this.#foo = foo;\n    }\n}\n\n구현에 대한 더 많은 정보는, the original pull request를 참고하세요\n어떤 것을 사용해야 할까요? (Which should I use?)\n이미 TypeScript 유저로서 어떤 종류의 비공개를 사용해야 하는지에 대한 많은 질문을 받았습니다: 주로, \"private 키워드를 사용해야 하나요 아니면 ECMAScript의 해시/우물 (#) 비공개 필드를 사용해야 하나요?\"\n상황마다 다릅니다!\n프로퍼티에서, TypeScript의 private 지정자는 완전히 지워집니다 - 이는 런타임에서는 완전히 일반 프로퍼티처럼 동작하며 이것이 private 지정자로 선언되었다고 알릴 방법이 없습니다.\nprivate 키워드를 사용할 때, 비공개는 오직 컴파일-타임/디자인-타임에만 시행되며, JavaScript 사용자에게는 전적으로 의도-기반입니다.\nclass C {\n    private foo = 10;\n}\n\n// 이는 컴파일 타임에 오류이지만\n// TypeScript 가 .js 파일로 출력했을 때는\n// 잘 동작하며 '10'을 출력합니다.\nconsole.log(new C().foo);    // '10' 출력\n//                  ~~~\n// error! Property 'foo' is private and only accessible within class 'C'.\n\n// TypeScript 오류를 피하기 위한 \"해결 방법\" 으로\n// 캄파일 타임에 이것을 허용합니다.\nconsole.log(new C()[\"foo\"]); // prints '10'\n\n이 같은 종류의 \"약한 비공개(soft privacy)\"는 사용자가 API에 접근할 수 없는 상태에서 일시적으로 작업을 하는 데 도움이 되며, 어떤 런타임에서도 동작합니다.\n반면에, ECMAScript의 # 비공개는 완벽하게 클래스 밖에서 접근 불가능합니다.\nclass C {\n    #foo = 10;\n}\n\nconsole.log(new C().#foo); // SyntaxError\n//                  ~~~~\n// TypeScript 는 오류를 보고 하며 *또한*\n// 런타임에도 동작하지 않습니다.\n\nconsole.log(new C()[\"#foo\"]); // undefined 출력\n//          ~~~~~~~~~~~~~~~\n// TypeScript 는 'noImplicitAny' 하에서 오류를 보고하며\n// `undefined`를 출력합니다.\n\n이런 강한 비공개(hard privacy)는 아무도 내부를 사용할 수 없도록 엄격하게 보장하는데 유용합니다.\n만약 라이브러리 작성자일 경우, 비공개 필드를 제거하거나 이름을 바꾸는 것이 급격한 변화를 초래서는 안됩니다.\n언급했듯이, 다른 장점은 ECMAScript의 # 비공개가 진짜 비공개이기 때문에 서브클래싱을 쉽게 할 수 있다는 것입니다.\nECMAScript # 비공개 필드를 사용하면, 어떤 서브 클래스도 필드 네이밍 충돌에 대해 걱정할 필요가 없습니다.\nTypeScript의 private프로퍼티 선언에서는, 사용자는 여전히 상위 클래스에 선언된 프로퍼티를 짓밟지  않도록 주의해야 합니다.\n한 가지 더 생각해봐야 할 것은 코드가 실행되기를 의도하는 곳입니다.\n현재 TypeScript는 이 기능을 ECMAScript 2015 (ES6) 이상 버전을 대상으로 하지 않으면 지원할 수 없습니다.\n이는 하위 레벨 구현이 비공개를 강제하기 위해 WeakMap을 사용하는데, WeakMap은 메모리 누수를 잃으키지 않도록 폴리필될 수 없기 때문입니다.\n반면, TypeScript의 private-선언 프로퍼티는 모든 대상에서 동작합니다- ECMAScript3에서도!\n마지막 고려 사항은 속도 일수 있습니다: private 프로퍼티는 다른 어떤 프로퍼티와 다르지 않기 때문에, 어떤 런타임을 대상으로 하단 다른 프로퍼티와 마찬가지로 접근 속도가 빠를 수 있습니다.\n반면에, # 비공개 필드는 WeakMap을 이용해 다운 레벨 되기 때문에 사용 속도가 느려질 수 있습니다.\n어떤 런타임은 # 비공개 필드 구현을 최적화 하고, 더 빠른 WeakMap을 구현하고 싶을 수 있지만, 모든 런타임에서 그렇지 않을 수 있습니다.\n export * as ns 구문 (export * as ns Syntax)\n다른 모듈의 모든 멤버를 하나의 멤버로 내보내는 단일 진입점을 갖는 것은 종종 일반적입니다.\nimport * as utilities from \"./utilities.js\";\nexport { utilities };\n\n이는 매우 일반적이어서 ECMAScript2020은 최근에 이 패턴을 지원하기 위해서 새로운 구문을 추가했습니다.\nexport * as utilities from \"./utilities.js\";\n\n이것은 JavaScript에 대한 훌륭한 삶의 질의 향상이며, TypeScript 3.8은 이 구문을 지원합니다.\n모듈 대상이 es2020 이전인 경우, TypeScript는 첫 번째 줄의 코드 스니펫을 따라서 무언가를 출력할 것입니다.\n 최상위-레벨 await (Top-Level await)\nTypeScript 3.8은 \"최상위-레벨 await\"이라는 편리한 ECMAScript 기능을 지원합니다.\nJavaScript 사용자는 await을 사용하기 위해 async 함수를 도입하는 경우가 많으며, 이를 정의한 후 즉시 함수를 호출합니다.\nasync function main() {\n    const response = await fetch(\"...\");\n    const greeting = await response.text();\n    console.log(greeting);\n}\n\nmain()\n    .catch(e => console.error(e))\n\n이전의 JavaScript(유사한 기능을 가진 대부분의 다른 언어들과 함께)에서 await은 async 함수 내에서 만 허용되었기 때문입니다.\n하지만 최상위-레벨 await로, 우리는 모듈의 최상위 레벨에서 await을 사용할 수 있습니다.\nconst response = await fetch(\"...\");\nconst greeting = await response.text();\nconsole.log(greeting);\n\n// 모듈인지 확인\nexport {};\n\n유의할 점이 있습니다: 최상위-레벨 await은 module의 최상위 레벨에서만 동작하며, 파일은 TypeScript가 import나 export를 찾을 때에만 모듈로 간주됩니다.\n일부 기본적인 경우에 export {}와 같은 보일러 플레이트를 작성하여 이를 확인할 필요가 있습니다.\n이러한 경우가 예상되는 모든 환경에서 최상위 레벨 await은 동작하지 않을 수 있습니다.\n현재, target 컴파일러 옵션이 es2017 이상이고, module이 esnext 또는 system인 경우에만 최상위 레벨 await을 사용할 수 있습니다.\n몇몇 환경과 번들러내에서의 지원은 제한적으로 작동하거나 실험적 지원을 활성화해야 할 수도 있습니다.\n구현에 관한 더 자세한 정보는 the original pull request을 확인하세요.\n es2020용 target과 module   (es2020 for target and module)\nTypeScript 3.8은 es2020을 module과 target 옵션으로 지원합니다.\n이를 통해 선택적 체이닝 (optional chaining), nullish 병합 (nullish coalescing), export * as ns 그리고 동적인 import(...) 구문과 같은 ECMAScript 2020 기능이 유지됩니다.\n또한 bigint 리터럴이 esnext 아래에 안정적인 target을 갖는 것을 의미합니다.\n JSDoc 프로퍼티 지정자 (JSDoc Property Modifiers)\nTypeScript 3.8는 allowJs 플래그를 사용하여 JavaScript 파일을 지원하고 checkJs 옵션이나 // @ts-check 주석을 .js 파일 맨 위에 추가하여 JavaScript 파일의 타입-검사를 지원합니다.\nJavaScript 파일에는 타입-검사를 위한 전용 구문이 없기 때문에 TypeScript는 JSDoc을 활용합니다.\nTypeScript 3.8은 프로퍼티에 대한 몇 가지 새로운 JSDoc 태그를 인식합니다.\n먼저 접근 지정자입니다: @public, @private 그리고 @protected입니다.\n이 태그들은 TypeScript 내에서 각각 public, private, protected와 동일하게 동작합니다.\n// @ts-check\n\nclass Foo {\n    constructor() {\n        /** @private */\n        this.stuff = 100;\n    }\n\n    printStuff() {\n        console.log(this.stuff);\n    }\n}\n\nnew Foo().stuff;\n//        ~~~~~\n// 오류! 'stuff' 프로퍼티는 private 이기 때문에 오직 'Foo' 클래스 내에서만 접근이 가능합니다.\n\n\n@public은 항상 암시적이며 생략될 수 있지만, 어디서든 해당 프로퍼티에 접근 가능을 의미합니다.\n@private은 오직 프로퍼티를 포함하는 클래스 내에서 해당 프로퍼티 사용 가능을 의미합니다.\n@protected는 프로퍼티를 포함하는 클래스와 파생된 모든 하위 클래스내에서 해당 프로퍼티를 사용할 수 있지만, 포함하는 클래스의 인스턴스는 해당 프로퍼티를 사용할 수 없습니다.\n\n다음으로 @readonly 지정자를 추가하여 프로퍼티가 초기화 과정 내에서만 값이 쓰이는 것을 보장합니다.\n// @ts-check\n\nclass Foo {\n    constructor() {\n        /** @readonly */\n        this.stuff = 100;\n    }\n\n    writeToStuff() {\n        this.stuff = 200;\n        //   ~~~~~\n        // 'stuff'는 읽기-전용(read-only) 프로퍼티이기 때문에 할당할 수 없습니다.\n    }\n}\n\nnew Foo().stuff++;\n//        ~~~~~\n// 'stuff'는 읽기-전용(read-only) 프로퍼티이기 때문에 할당할 수 없습니다.\n\n 리눅스에서 더 나은 디렉터리 감시와 watchOptions\nTypeScript 3.8에서는 node_modules의 변경사항을 효율적으로 수집하는데 중요한 새로운 디렉터리 감시 전략을 제공합니다.\n리눅스와 같은 운영체제에서 TypeScript는 node_modules에 디렉터리 왓쳐(파일 왓쳐와는 반대로)를 설치하고, 의존성 변화를 감지하기 위해 많은 하위 디렉터리를 설치합니다.\n왜냐하면 사용 가능한 파일 왓쳐의 수는 종종 node_modules의 파일 수에 의해 가려지기 때문이고, 추적할 디렉터리 수가 적기 때문입니다.\nTypeScript의 이전 버전은 폴더에 디렉터리 왓쳐를 즉시 설치하며, 초기에는 괜찮을 겁니다; 하지만, npm install 할 때, node_modules안에서 많은 일들이 발생할 것이고, TypeScript를 압도하여, 종종 에디터 세션을 아주 느리게 만듭니다.\n이를 방지하기 위해, TypeScript 3.8은 디렉터리 왓쳐를 설치하기 전에 조금 기다려서 변동성이 높은 디렉터리에게 안정될 수 있는 시간을 줍니다.\n왜냐하면 모든 프로젝트는 다른 전략에서 더 잘 작동할 수 있고, 이 새로운 방법은 당신의 작업 흐름에서는 잘 맞지 않을 수 있습니다. TypeScript 3.8은 파일과 디렉터리를 감시하는데 어떤 감시 전략을 사용할지 컴파일러/언어 서비스에 알려줄 수 있도록 tsconfig.json과 jsconfig.json에 watchOptions란 새로운 필드를 제공합니다.\n{\n    // 일반적인 컴파일러 옵션들\n    \"compilerOptions\": {\n        \"target\": \"es2020\",\n        \"moduleResolution\": \"node\",\n        // ...\n    },\n\n    // NEW: 파일/디렉터리 감시를 위한 옵션\n    \"watchOptions\": {\n        // 파일과 디렉터리에 네이티브 파일 시스템 이벤트 사용\n        \"watchFile\": \"useFsEvents\",\n        \"watchDirectory\": \"useFsEvents\",\n\n        // 업데이트가 빈번할 때\n        // 업데이트하기 위해 더 자주 파일을 폴링\n        \"fallbackPolling\": \"dynamicPriority\"\n    }\n}\n\nwatchOptions는 구성할 수 있는 4가지 새로운 옵션이 포함되어 있습니다.\n\nwatchFile: 각 파일의 감시 방법 전략. 다음과 같이 설정할 수 있습니다:\nfixedPollingInterval: 고정된 간격으로 모든 파일의 변경을 1초에 여러 번 검사합니다.\npriorityPollingInterval: 모든 파일의 변경을 1초에 여러 번 검사합니다, 하지만 휴리스틱을 사용하여 특정 타입의 파일은 다른 타입의 파일보다 덜 자주 검사합니다.\ndynamicPriorityPolling: 동적 큐를 사용하여 덜-자주 수정된 파일은 적게 검사합니다.\nuseFsEvents (디폴트): 파일 변화에 운영체제/파일 시스템의 네이티브 이벤트를 사용합니다.\nuseFsEventsOnParentDirectory: 파일을 포함하고 있는 디렉터리 변경을 감지할 때, 운영체제/파일 시스템의 네이티브 이벤트를 사용합니다. 파일 왓쳐를 적게 사용할 수 있지만, 덜 정확할 수 있습니다.\n\n\nwatchDirectory: 재귀적인 파일-감시 기능이 없는 시스템 안에서 전체 디렉터리 트리가 감시되는 전략. 다음과 같이 설정할 수 있습니다:\nfixedPollingInterval: 고정된 간격으로 모든 디렉터리의 변경을 1초에 여러 번 검사합니다.\ndynamicPriorityPolling: 동적 큐를 사용하여 덜-자주 수정된 디렉터리는 적게 검사합니다.\nuseFsEvents (디폴트): 디렉터리 변경에 운영체제/파일 시스템의 네이티브 이벤트를 사용합니다.\n\n\nfallbackPolling: 파일 시스템 이벤트를 사용할 때, 이 옵션은 시스템이 네이티브 파일 왓쳐가 부족하거나/혹은 지원하지 않을 때, 사용되는 폴링 전략을 지정합니다. 다음과 같이 설정할 수 있습니다.\nfixedPollingInterval: (위를 참조하세요.)\npriorityPollingInterval: (위를 참조하세요.)\ndynamicPriorityPolling: (위를 참조하세요.)\n\n\nsynchronousWatchDirectory: 디렉터리의 연기된 감시를 비활성화합니다. 연기된 감시는 많은 파일이 한 번에 변경될 때 유용합니다 (예를 들어, npm install을 실행하여 node_modules의 변경), 하지만 덜-일반적인 설정을 위해 비활성화할 수도 있습니다.\n\n이 변경의 더 자세한 내용은 Github으로 이동하여 the pull request를 읽어보세요.\n \"빠르고 느슨한\" 증분 검사\nTypeScript 3.8은 새로운 컴파일러 옵션 assumeChangesOnlyAffectDirectDepencies을 제공합니다.\n이 옵션이 활성화되면, TypeScript는 정말로 영향을 받은 파일들은 재검사/재빌드하지않고, 변경된 파일뿐만 아니라 직접 import 한 파일만 재검사/재빌드 합니다.\n예를 들어, 다음과 같이 fileA.ts를 import 한 fileB.ts를 import 한 fileC.ts를 import 한 fileD.ts를 살펴봅시다:\nfileA.ts \n--watch 모드에서는, fileA.ts의 변경이 fileB.ts, fileC.ts 그리고 fileD.ts를 TypeScript가 재-검사해야 한다는 의미입니다.\nassumeChangesOnlyAffectDirectDependencies에서는 fileA.ts의 변경은 fileA.ts와 fileB.ts만 재-검사하면 됩니다.\nVisual Studio Code와 같은 코드 베이스에서는, 특정 파일의 변경에 대해 약 14초에서 약 1초로 재빌드 시간을 줄여주었습니다.\n이 옵션을 모든 코드 베이스에서 추천하는 것은 아니지만, 큰 코드 베이스를 가지고 있고, 나중까지 전체 프로젝트 오류를 기꺼이 연기하겠다면 (예를 들어, tsconfig.fullbuild.json이나 CI를 통한 전용 빌드) 흥미로울 것입니다.\n더 자세한 내용은 the original pull request에서 보실 수 있습니다.\n"}}}
\ No newline at end of file
diff --git a/sitemap.xml b/sitemap.xml
index 32004e73..6d7748cd 100644
--- a/sitemap.xml
+++ b/sitemap.xml
@@ -28,6 +28,7 @@
  https://typescript-kr.github.io/pages/Mixins.html weekly 0.5 
  https://typescript-kr.github.io/pages/Triple-Slash Directives.html weekly 0.5 
  https://typescript-kr.github.io/pages/Type Checking JavaScript Files.html weekly 0.5 
+ https://typescript-kr.github.io/pages/Utility Types.html weekly 0.5 
  https://typescript-kr.github.io/pages/declaration files/Introduction.html weekly 0.5 
  https://typescript-kr.github.io/pages/declaration files/Library Structures.html weekly 0.5 
  https://typescript-kr.github.io/pages/declaration files/By Example.html weekly 0.5 
@@ -38,7 +39,9 @@
  https://typescript-kr.github.io/pages/declaration files/Consumption.html weekly 0.5 
  https://typescript-kr.github.io/pages/tsconfig.json.html weekly 0.5 
  https://typescript-kr.github.io/pages/Compiler Options.html weekly 0.5 
+ https://typescript-kr.github.io/pages/Project References.html weekly 0.5 
  https://typescript-kr.github.io/pages/Compiler Options in MSBuild.html weekly 0.5 
  https://typescript-kr.github.io/pages/Integrating with Build Tools.html weekly 0.5 
  https://typescript-kr.github.io/pages/Nightly Builds.html weekly 0.5 
+ https://typescript-kr.github.io/pages/release notes/TypeScript 3.8.html weekly 0.5 
 
\ No newline at end of file